Asynchronous run_script_async using asyncio.subprocess.

Asynchronous question generators. Asynchronous correction of textarea questions. Removes 'lines' option in textarea questions (unused in codemirror). The async implementations fixes errors with threading and sqlalchemy.

Asynchronous run_script_async using asyncio.subprocess.
Asynchronous question generators. Asynchronous correction of textarea questions. Removes 'lines' option in textarea questions (unused in codemirror). The async implementations fixes errors with threading and sqlalchemy.
Miguel Barão
1 parent c2abd6bf
Showing 10 changed files with 174 additions and 68 deletions Show diff stats
BUGS.md
aprendizations/knowledge.py
aprendizations/learnapp.py
aprendizations/questions.py
aprendizations/serve.py
aprendizations/templates/question-textarea.html
aprendizations/tools.py
demo/math/questions.yaml
demo/solar_system/correct-first_3_planets.py
demo/solar_system/questions.yaml
 # BUGS
+- quando termina topico devia apagar as perguntas todas (se falhar a gerar novo topico, aparecem perguntas do antigo)
+- apos clicar no botao responder, inactivar o input (importante quando o tempo de correcção é grande)
+- devia mostrar timout para o aluno saber a razao.
 - permitir configuracao para escolher entre static files locais ou remotos
 - sqlalchemy.pool.impl.NullPool: Exception during reset or similar
 sqlite3.ProgrammingError: SQLite objects created in a thread can only be used in that same thread.
@@ -58,7 +58,7 @@ class StudentKnowledge(object):
                         'level': 0.0,           # unlocked
                         'date': datetime.now()
                         }
-                    logger.debug(f'Unlocked "{topic}".')
+                    logger.debug(f'[unlock_topics] Unlocked "{topic}".')
                 # else:  # lock this topic if deps do not satisfy min_level
                 #     del self.state[topic]
@@ -68,7 +68,7 @@ class StudentKnowledge(object):
     #    current_question: the current question to be presented
     # ------------------------------------------------------------------------
     async def start_topic(self, topic):
-        logger.debug('StudentKnowledge.start_topic()')
+        logger.debug(f'[start_topic] topic "{topic}"')
         if self.current_topic == topic:
             logger.info('Restarting current topic is not allowed.')
@@ -76,7 +76,7 @@ class StudentKnowledge(object):
         # do not allow locked topics
         if self.is_locked(topic):
-            logger.debug(f'Topic {topic} is locked')
+            logger.debug(f'[start_topic] topic "{topic}" is locked')
             return False
         # starting new topic
@@ -90,23 +90,20 @@ class StudentKnowledge(object):
             questions = random.sample(t['questions'], k=k)
         else:
             questions = t['questions'][:k]
-        logger.debug(f'Questions: {", ".join(questions)}')
+        logger.debug(f'[start_topic] questions: {", ".join(questions)}')
-        # generate instances of questions
+        # synchronous
+        # self.questions = [self.factory[ref].generate()
+        #                   for ref in questions]
-        # synchronous:
-        # self.questions = [self.factory[ref].generate() for ref in questions]
-
-        # async:
-        loop = asyncio.get_running_loop()
-        generators = [loop.run_in_executor(None, self.factory[qref].generate)
-                      for qref in questions]
-        self.questions = await asyncio.gather(*generators)
+        # asynchronous:
+        self.questions = [await self.factory[ref].generate_async()
+                          for ref in questions]
         # get first question
         self.next_question()
-        logger.debug(f'Generated {len(self.questions)} questions')
+        logger.debug(f'[start_topic] generated {len(self.questions)} questions')
         return True
     # ------------------------------------------------------------------------
@@ -115,7 +112,7 @@ class StudentKnowledge(object):
     # The current topic is unchanged.
     # ------------------------------------------------------------------------
     def finish_topic(self):
-        logger.debug(f'StudentKnowledge.finish_topic({self.current_topic})')
+        logger.debug(f'[finish_topic] current_topic {self.current_topic}')
         self.state[self.current_topic] = {
             'date': datetime.now(),
@@ -132,13 +129,13 @@ class StudentKnowledge(object):
     #   - if wrong, counts number of tries. If exceeded, moves on.
     # ------------------------------------------------------------------------
     async def check_answer(self, answer):
-        logger.debug('StudentKnowledge.check_answer()')
+        logger.debug('[check_answer]')
         q = self.current_question
         q['answer'] = answer
         q['finish_time'] = datetime.now()
         await q.correct_async()
-        logger.debug(f'Grade {q["grade"]:.2} ({q["ref"]})')
+        logger.debug(f'[check_answer] Grade {q["grade"]:.2} in {q["ref"]}')
         if q['grade'] > 0.999:
             self.correct_answers += 1
@@ -154,7 +151,7 @@ class StudentKnowledge(object):
             else:
                 action = 'wrong'
                 if self.current_question['append_wrong']:
-                    logger.debug("Append new instance of question at the end")
+                    logger.debug('[check_answer] Wrong, append new instance')
                     self.questions.append(self.factory[q['ref']].generate())
                 self.next_question()
@@ -175,7 +172,7 @@ class StudentKnowledge(object):
             default_maxtries = self.deps.nodes[self.current_topic]['max_tries']
             maxtries = self.current_question.get('max_tries', default_maxtries)
             self.current_question['tries'] = maxtries
-            logger.debug(f'Next question is "{self.current_question["ref"]}"')
+            logger.debug(f'[next_question] "{self.current_question["ref"]}"')
         return self.current_question  # question or None
@@ -75,7 +75,7 @@ class LearnApp(object):
         errors = 0
         for qref in self.factory:
-            logger.debug(f'Checking "{qref}"...')
+            logger.debug(f'[sanity_check_questions] Checking "{qref}"...')
             try:
                 q = self.factory[qref].generate()
             except Exception:
@@ -102,7 +102,7 @@ class LearnApp(object):
                         continue  # to next test
         if errors > 0:
-            logger.info(f'{errors:>6} errors found.')
+            logger.error(f'{errors:>6} errors found.')
             raise LearnException('Sanity checks')
         else:
             logger.info('No errors found.')
@@ -204,7 +204,7 @@ class LearnApp(object):
                 finishtime=str(q['finish_time']),
                 student_id=uid,
                 topic_id=topic))
-            logger.debug(f'Saved "{q["ref"]}" into database')
+            logger.debug(f'[check_answer] Saved "{q["ref"]}" into database')
         if knowledge.topic_has_finished():
             # finished topic, save into database
@@ -218,7 +218,7 @@ class LearnApp(object):
                     .one_or_none()
                 if a is None:
                     # insert new studenttopic into database
-                    logger.debug('Database insert new studenttopic')
+                    logger.debug('[check_answer] Database insert studenttopic')
                     t = s.query(Topic).get(topic)
                     u = s.query(Student).get(uid)
                     # association object
@@ -227,13 +227,13 @@ class LearnApp(object):
                     u.topics.append(a)
                 else:
                     # update studenttopic in database
-                    logger.debug('Database update studenttopic')
+                    logger.debug('[check_answer] Database update studenttopic')
                     a.level = level
                     a.date = date
                 s.add(a)
-            logger.debug(f'Saved topic "{topic}" into database')
+            logger.debug(f'[check_answer] Saved topic "{topic}" into database')
         return q, action
@@ -244,8 +244,8 @@ class LearnApp(object):
         student = self.online[uid]['state']
         try:
             await student.start_topic(topic)
-        except Exception:
-            logger.warning(f'User "{uid}" could not start topic "{topic}"')
+        except Exception as e:
+            logger.warning(f'User "{uid}" couldn\'t start "{topic}": {e}')
         else:
             logger.info(f'User "{uid}" started topic "{topic}"')
@@ -4,12 +4,11 @@ import random
 import re
 from os import path
 import logging
-import asyncio
 from typing import Any, Dict, NewType
 import uuid
 # this project
-from .tools import run_script
+from .tools import run_script, run_script_async
 # setup logger for this module
 logger = logging.getLogger(__name__)
@@ -50,8 +49,9 @@ class Question(dict):
         self['grade'] = 0.0
     async def correct_async(self) -> None:
-        loop = asyncio.get_running_loop()
-        await loop.run_in_executor(None, self.correct)
+        self.correct()
+        # loop = asyncio.get_running_loop()
+        # await loop.run_in_executor(None, self.correct)
     def set_defaults(self, d: QDict) -> None:
         'Add k:v pairs from default dict d for nonexistent keys'
@@ -305,7 +305,7 @@ class QuestionNumericInterval(Question):
                 answer = float(self['answer'].replace(',', '.', 1))
             except ValueError:
                 self['comments'] = ('A resposta tem de ser numérica, '
-                                    'por exemplo 12.345.')
+                                    'por exemplo `12.345`.')
                 self['grade'] = 0.0
             else:
                 self['grade'] = 1.0 if lower <= answer <= upper else 0.0
@@ -318,7 +318,6 @@ class QuestionTextArea(Question):
         text (str)
         correct (str with script to run)
         answer (None or an actual answer)
-        lines (int)
     '''
     # ------------------------------------------------------------------------
@@ -327,13 +326,12 @@ class QuestionTextArea(Question):
         self.set_defaults(QDict({
             'text': '',
-            'lines': 8,
-            'timeout': 5,  # seconds
+            'timeout': 5,   # seconds
             'correct': '',  # trying to execute this will fail => grade 0.0
             'args': []
             }))
-        self['correct'] = path.join(self['path'], self['correct'])   # FIXME
+        self['correct'] = path.join(self['path'], self['correct'])
     # ------------------------------------------------------------------------
     def correct(self) -> None:
@@ -347,7 +345,39 @@ class QuestionTextArea(Question):
                 timeout=self['timeout']
                 )
-            if isinstance(out, dict):
+            if out is None:
+                logger.warning(f'No grade after running "{self["correct"]}".')
+                self['grade'] = 0.0
+            elif isinstance(out, dict):
+                self['comments'] = out.get('comments', '')
+                try:
+                    self['grade'] = float(out['grade'])
+                except ValueError:
+                    logger.error(f'Output error in "{self["correct"]}".')
+                except KeyError:
+                    logger.error(f'No grade in "{self["correct"]}".')
+            else:
+                try:
+                    self['grade'] = float(out)
+                except (TypeError, ValueError):
+                    logger.error(f'Invalid grade in "{self["correct"]}".')
+
+    # ------------------------------------------------------------------------
+    async def correct_async(self) -> None:
+        super().correct()
+
+        if self['answer'] is not None:  # correct answer and parse yaml ouput
+            out = await run_script_async(
+                script=self['correct'],
+                args=self['args'],
+                stdin=self['answer'],
+                timeout=self['timeout']
+                )
+
+            if out is None:
+                logger.warning(f'No grade after running "{self["correct"]}".')
+                self['grade'] = 0.0
+            elif isinstance(out, dict):
                 self['comments'] = out.get('comments', '')
                 try:
                     self['grade'] = float(out['grade'])
@@ -372,7 +402,6 @@ class QuestionInformation(Question):
             }))
     # ------------------------------------------------------------------------
-    # can return negative values for wrong answers
     def correct(self) -> None:
         super().correct()
         self['grade'] = 1.0  # always "correct" but points should be zero!
@@ -400,7 +429,7 @@ class QuestionInformation(Question):
 #   # answer one question and correct it
 #   question['answer'] = 42          # set answer
 #   question.correct()               # correct answer
-#   print(question['grade'])         # print grade
+#   grade = question['grade']        # get grade
 # ===========================================================================
 class QFactory(object):
     # Depending on the type of question, a different question class will be
@@ -427,7 +456,7 @@ class QFactory(object):
     # i.e. a question object (radio, checkbox, ...).
     # -----------------------------------------------------------------------
     def generate(self) -> Question:
-        logger.debug(f'Generating "{self.question["ref"]}"...')
+        logger.debug(f'[generate] "{self.question["ref"]}"...')
         # Shallow copy so that script generated questions will not replace
         # the original generators
         q = self.question.copy()
@@ -439,7 +468,7 @@ class QFactory(object):
         if q['type'] == 'generator':
             logger.debug(f' \\_ Running "{q["script"]}".')
             q.setdefault('args', [])
-            q.setdefault('stdin', '')  # FIXME does not exist anymore?
+            q.setdefault('stdin', '')  # FIXME is it really necessary?
             script = path.join(q['path'], q['script'])
             out = run_script(script=script, args=q['args'], stdin=q['stdin'])
             q.update(out)
@@ -455,3 +484,36 @@ class QFactory(object):
             raise
         else:
             return qinstance
+
+    # -----------------------------------------------------------------------
+    async def generate_async(self) -> Question:
+        logger.debug(f'[generate_async] "{self.question["ref"]}"...')
+        # Shallow copy so that script generated questions will not replace
+        # the original generators
+        q = self.question.copy()
+        q['qid'] = str(uuid.uuid4())  # unique for each generated question
+
+        # If question is of generator type, an external program will be run
+        # which will print a valid question in yaml format to stdout. This
+        # output is then yaml parsed into a dictionary `q`.
+        if q['type'] == 'generator':
+            logger.debug(f' \\_ Running "{q["script"]}".')
+            q.setdefault('args', [])
+            q.setdefault('stdin', '')  # FIXME is it really necessary?
+            script = path.join(q['path'], q['script'])
+            out = await run_script_async(script=script, args=q['args'],
+                                         stdin=q['stdin'])
+            q.update(out)
+
+        # Finally we create an instance of Question()
+        try:
+            qinstance = self._types[q['type']](QDict(q))  # of matching class
+        except QuestionException as e:
+            logger.error(e)
+            raise e
+        except KeyError:
+            logger.error(f'Invalid type "{q["type"]}" in "{q["ref"]}"')
+            raise
+        else:
+            logger.debug(f'[generate_async] Done instance of {q["ref"]}')
+            return qinstance
 #!/usr/bin/env python3
 # python standard library
-import sys
+import argparse
+import asyncio
 import base64
-import uuid
+import functools
 import logging.config
-import argparse
 import mimetypes
+from os import path, environ
 import signal
-import functools
 import ssl
-import asyncio
-from os import path, environ
+import sys
+import uuid
+
 # third party libraries
 import tornado.ioloop
@@ -253,7 +254,7 @@ class QuestionHandler(BaseHandler):
     # --- get question to render
     @tornado.web.authenticated
     def get(self):
-        logging.debug('QuestionHandler.get()')
+        logging.debug('[QuestionHandler.get]')
         user = self.current_user
         q = self.learn.get_current_question(user)
@@ -284,7 +285,7 @@ class QuestionHandler(BaseHandler):
     # --- post answer, returns what to do next: shake, new_question, finished
     @tornado.web.authenticated
     async def post(self) -> None:
-        logging.debug('QuestionHandler.post()')
+        logging.debug('[QuestionHandler.post]')
         user = self.current_user
         answer = self.get_body_arguments('answer')  # list
@@ -2,7 +2,7 @@
 {% block answer %}
-<textarea class="form-control" rows="{{ question['lines'] }}" name="answer" id="code" autofocus>{{ question['answer'] or '' }}</textarea><br />
+<textarea class="form-control" name="answer" id="code" autofocus>{{ question['answer'] or '' }}</textarea><br />
 <input type="hidden" name="qid" value="{{ question['qid'] }}">
 <script>
 # python standard library
-from os import path
-import subprocess
+import asyncio
 import logging
+from os import path
 import re
+import subprocess
 from typing import Any, List
 # third party libraries
-import yaml
 import mistune
 from pygments import highlight
 from pygments.lexers import get_lexer_by_name
 from pygments.formatters import HtmlFormatter
+import yaml
+
 # setup logger for this module
 logger = logging.getLogger(__name__)
@@ -101,7 +103,7 @@ class HighlightRenderer(mistune.Renderer):
     def table(self, header, body):
         return '<table class="table table-sm"><thead class="thead-light">' \
-               + header + '</thead><tbody>' + body + "</tbody></table>"
+               + header + '</thead><tbody>' + body + '</tbody></table>'
     def image(self, src, title, alt):
         alt = mistune.escape(alt, quote=True)
@@ -168,7 +170,7 @@ def load_yaml(filename: str, default: Any = None) -&gt; Any:
 def run_script(script: str,
                args: List[str] = [],
                stdin: str = '',
-               timeout: int = 5) -> Any:
+               timeout: int = 2) -> Any:
     script = path.expanduser(script)
     try:
@@ -200,3 +202,41 @@ def run_script(script: str,
                 logger.error(f'Error parsing yaml output of "{script}"')
             else:
                 return output
+
+
+# ----------------------------------------------------------------------------
+# Same as above, but asynchronous
+# ----------------------------------------------------------------------------
+async def run_script_async(script: str,
+                           args: List[str] = [],
+                           stdin: str = '',
+                           timeout: int = 2) -> Any:
+
+    script = path.expanduser(script)
+    args = [str(a) for a in args]
+
+    p = await asyncio.create_subprocess_exec(
+        script, *args,
+        stdin=asyncio.subprocess.PIPE,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.DEVNULL,
+        )
+
+    try:
+        stdout, stderr = await asyncio.wait_for(
+            p.communicate(input=stdin.encode('utf-8')),
+            timeout=timeout
+            )
+    except asyncio.TimeoutError:
+        logger.warning(f'Timeout {timeout}s running script "{script}".')
+        return
+
+    if p.returncode != 0:
+        logger.error(f'Return code {p.returncode} running "{script}".')
+    else:
+        try:
+            output = yaml.safe_load(stdout.decode('utf-8', 'ignore'))
+        except Exception:
+            logger.error(f'Error parsing yaml output of "{script}"')
+        else:
+            return output
@@ -16,6 +16,7 @@
     - $2\times(9-2\times 3)$
   correct: [1, 1, 0, 0, 0]
   choose: 3
+  max_tries: 1
   solution: |
     Colocando o 2 em evidência, obtém-se a resposta correcta $2\times(9 - 3)$
     ou $(9-3)\times 2$.
@@ -50,6 +51,7 @@
     - 12
     - 14
     - 1, a **unidade**
+  max_tries: 1
   solution: |
     O único número primo é o 13.
@@ -76,9 +78,10 @@
     números negativos são menores que os positivos.
 # ---------------------------------------------------------------------------
+# the program should print a question in yaml format. The args will be
+# sent as command line options when the program is run.
 - type: generator
   ref: overflow
   script: gen-multiples-of-3.py
   args: [11, 120]
-  # the program should print a question in yaml format. The args will be
-  # sent as command line options when the program is run.
+  choose: 3
@@ -2,26 +2,27 @@
 import re
 import sys
+import time
 s = sys.stdin.read()
-# set of words converted to lowercase
-answer = set(re.findall(r'[\w]+', s.lower()))
-answer.difference_update({'e', 'a', 'planeta', 'planetas'})  # ignore these
+ans = set(re.findall(r'[\w]+', s.lower()))  # convert answer to lowercase
+ans.difference_update({'e', 'a', 'o', 'planeta', 'planetas'})  # ignore words
 # correct set of planets
 planets = {'mercúrio', 'vénus', 'terra'}
-correct = set.intersection(answer, planets)     # the ones I got right
-wrong = set.difference(answer, planets)         # the ones I got wrong
+correct = set.intersection(ans, planets)     # the ones I got right
+wrong = set.difference(ans, planets)         # the ones I got wrong
 grade = (len(correct) - len(wrong)) / len(planets)
+comments = 'Certo' if grade == 1.0 else 'as iniciais dos planetas são M, V e T'
+
 out = f'''---
-grade: {grade}'''
+grade: {grade}
+comments: {comments}'''
-if grade < 1.0:
-    out += '\ncomments: Vou dar uma ajuda, as iniciais são M, V e T...'
+time.sleep(2)  # simulate computation time (may generate timeout)
 print(out)
-exit(0)
@@ -64,7 +64,6 @@
   # correct: correct-timeout.py
   # opcional
   answer: Vulcano, Krypton, Plutão
-  lines: 3
-  timeout: 50
+  timeout: 3
   solution: |
     Os 3 planetas mais perto do Sol são: Mercúrio, Vénus e Terra.
1		1
2	# BUGS	2	# BUGS
3		3
		4	+- quando termina topico devia apagar as perguntas todas (se falhar a gerar novo topico, aparecem perguntas do antigo)
		5	+- apos clicar no botao responder, inactivar o input (importante quando o tempo de correcção é grande)
		6	+- devia mostrar timout para o aluno saber a razao.
4	- permitir configuracao para escolher entre static files locais ou remotos	7	- permitir configuracao para escolher entre static files locais ou remotos
5	- sqlalchemy.pool.impl.NullPool: Exception during reset or similar	8	- sqlalchemy.pool.impl.NullPool: Exception during reset or similar
6	sqlite3.ProgrammingError: SQLite objects created in a thread can only be used in that same thread.	9	sqlite3.ProgrammingError: SQLite objects created in a thread can only be used in that same thread.
	@@ -2,7 +2,7 @@		@@ -2,7 +2,7 @@
2		2
3	{% block answer %}	3	{% block answer %}
4		4
5	-<textarea class="form-control" rows="{{ question['lines'] }}" name="answer" id="code" autofocus>{{ question['answer'] or '' }}</textarea><br />	5	+<textarea class="form-control" name="answer" id="code" autofocus>{{ question['answer'] or '' }}</textarea><br />
6	<input type="hidden" name="qid" value="{{ question['qid'] }}">	6	<input type="hidden" name="qid" value="{{ question['qid'] }}">
7		7
8	<script>	8	<script>
1		1
2	# python standard library	2	# python standard library
3	-from os import path
4	-import subprocess	3	+import asyncio
5	import logging	4	import logging
		5	+from os import path
6	import re	6	import re
		7	+import subprocess
7	from typing import Any, List	8	from typing import Any, List
8		9
9	# third party libraries	10	# third party libraries
10	-import yaml
11	import mistune	11	import mistune
12	from pygments import highlight	12	from pygments import highlight
13	from pygments.lexers import get_lexer_by_name	13	from pygments.lexers import get_lexer_by_name
14	from pygments.formatters import HtmlFormatter	14	from pygments.formatters import HtmlFormatter
		15	+import yaml
		16	+
15		17
16	# setup logger for this module	18	# setup logger for this module
17	logger = logging.getLogger(__name__)	19	logger = logging.getLogger(__name__)
	@@ -101,7 +103,7 @@ class HighlightRenderer(mistune.Renderer):		@@ -101,7 +103,7 @@ class HighlightRenderer(mistune.Renderer):
101		103
102	def table(self, header, body):	104	def table(self, header, body):
103	return '<table class="table table-sm"><thead class="thead-light">' \	105	return '<table class="table table-sm"><thead class="thead-light">' \
104	- + header + '</thead><tbody>' + body + "</tbody></table>"	106	+ + header + '</thead><tbody>' + body + '</tbody></table>'
105		107
106	def image(self, src, title, alt):	108	def image(self, src, title, alt):
107	alt = mistune.escape(alt, quote=True)	109	alt = mistune.escape(alt, quote=True)
	@@ -168,7 +170,7 @@ def load_yaml(filename: str, default: Any = None) -> Any:		@@ -168,7 +170,7 @@ def load_yaml(filename: str, default: Any = None) -> Any:
168	def run_script(script: str,	170	def run_script(script: str,
169	args: List[str] = [],	171	args: List[str] = [],
170	stdin: str = '',	172	stdin: str = '',
171	- timeout: int = 5) -> Any:	173	+ timeout: int = 2) -> Any:
172		174
173	script = path.expanduser(script)	175	script = path.expanduser(script)
174	try:	176	try:
	@@ -200,3 +202,41 @@ def run_script(script: str,		@@ -200,3 +202,41 @@ def run_script(script: str,
200	logger.error(f'Error parsing yaml output of "{script}"')	202	logger.error(f'Error parsing yaml output of "{script}"')
201	else:	203	else:
202	return output	204	return output
		205	+
		206	+
		207	+# ----------------------------------------------------------------------------
		208	+# Same as above, but asynchronous
		209	+# ----------------------------------------------------------------------------
		210	+async def run_script_async(script: str,
		211	+ args: List[str] = [],
		212	+ stdin: str = '',
		213	+ timeout: int = 2) -> Any:
		214	+
		215	+ script = path.expanduser(script)
		216	+ args = [str(a) for a in args]
		217	+
		218	+ p = await asyncio.create_subprocess_exec(
		219	+ script, *args,
		220	+ stdin=asyncio.subprocess.PIPE,
		221	+ stdout=asyncio.subprocess.PIPE,
		222	+ stderr=asyncio.subprocess.DEVNULL,
		223	+ )
		224	+
		225	+ try:
		226	+ stdout, stderr = await asyncio.wait_for(
		227	+ p.communicate(input=stdin.encode('utf-8')),
		228	+ timeout=timeout
		229	+ )
		230	+ except asyncio.TimeoutError:
		231	+ logger.warning(f'Timeout {timeout}s running script "{script}".')
		232	+ return
		233	+
		234	+ if p.returncode != 0:
		235	+ logger.error(f'Return code {p.returncode} running "{script}".')
		236	+ else:
		237	+ try:
		238	+ output = yaml.safe_load(stdout.decode('utf-8', 'ignore'))
		239	+ except Exception:
		240	+ logger.error(f'Error parsing yaml output of "{script}"')
		241	+ else:
		242	+ return output