fix mostly flake8 errors

Miguel Barão
1 parent 26c0d61d
Showing 10 changed files with 180 additions and 150 deletions Show diff stats
aprendizations/factory.py
aprendizations/initdb.py
aprendizations/knowledge.py
aprendizations/learnapp.py
aprendizations/models.py
aprendizations/questions.py
aprendizations/redirect.py
aprendizations/serve.py
aprendizations/tools.py
demo/solar_system/correct-first_3_planets.py
@@ -33,8 +33,9 @@ import logging
 # project
 from aprendizations.tools import run_script
 from aprendizations.questions import (QuestionInformation, QuestionRadio,
-    QuestionCheckbox, QuestionText, QuestionTextRegex, QuestionTextArea,
-    QuestionNumericInterval)
+                                      QuestionCheckbox, QuestionText,
+                                      QuestionTextRegex, QuestionTextArea,
+                                      QuestionNumericInterval)
 # setup logger for this module
 logger = logging.getLogger(__name__)
@@ -47,17 +48,17 @@ class QFactory(object):
     # Depending on the type of question, a different question class will be
     # instantiated. All these classes derive from the base class `Question`.
     _types = {
-        'radio'     : QuestionRadio,
-        'checkbox'  : QuestionCheckbox,
-        'text'      : QuestionText,
-        'text-regex': QuestionTextRegex,
+        'radio':        QuestionRadio,
+        'checkbox':     QuestionCheckbox,
+        'text':         QuestionText,
+        'text-regex':   QuestionTextRegex,
         'numeric-interval': QuestionNumericInterval,
-        'textarea'  : QuestionTextArea,
+        'textarea':     QuestionTextArea,
         # -- informative panels --
-        'information': QuestionInformation,
-        'warning'   : QuestionInformation,
-        'alert'     : QuestionInformation,
-        'success'   : QuestionInformation,
+        'information':  QuestionInformation,
+        'warning':      QuestionInformation,
+        'alert':        QuestionInformation,
+        'success':      QuestionInformation,
         }
     def __init__(self, question_dict={}):
@@ -82,17 +83,16 @@ class QFactory(object):
         # output is then yaml parsed into a dictionary `q`.
         if q['type'] == 'generator':
             logger.debug(f' \\_ Running "{q["script"]}".')
-            q.setdefault('arg', '') # optional arguments will be sent to stdin
+            q.setdefault('arg', '')  # optional arguments will be sent to stdin
             script = path.join(q['path'], q['script'])
             out = run_script(script=script, stdin=q['arg'])
             q.update(out)
         # Finally we create an instance of Question()
         try:
-            qinstance = self._types[q['type']](q)   # instance with correct class
+            qinstance = self._types[q['type']](q)  # instance matching class
         except KeyError as e:
-            logger.error(f'Unknown type "{q["type"]}" in question "{q["ref"]}"')
+            logger.error(f'Unknown type "{q["type"]}" in "{q["ref"]}"')
             raise e
         else:
             return qinstance
-
@@ -26,40 +26,40 @@ def parse_commandline_arguments():
                     ' is created.')
     argparser.add_argument('csvfile',
-        nargs='*',
-        type=str,
-        default='',
-        help='CSV file to import (SIIUE)')
+                           nargs='*',
+                           type=str,
+                           default='',
+                           help='CSV file to import (SIIUE)')
     argparser.add_argument('--db',
-        default='students.db',
-        type=str,
-        help='database file')
+                           default='students.db',
+                           type=str,
+                           help='database file')
     argparser.add_argument('-A', '--admin',
-        action='store_true',
-        help='insert the admin user')
+                           action='store_true',
+                           help='insert the admin user')
     argparser.add_argument('-a', '--add',
-        nargs=2,
-        action='append',
-        metavar=('uid', 'name'),
-        help='add new user')
+                           nargs=2,
+                           action='append',
+                           metavar=('uid', 'name'),
+                           help='add new user')
     argparser.add_argument('-u', '--update',
-        nargs='+',
-        metavar='uid',
-        default=[],
-        help='users to update')
+                           nargs='+',
+                           metavar='uid',
+                           default=[],
+                           help='users to update')
     argparser.add_argument('--pw',
-        default=None,
-        type=str,
-        help='set password for new and updated users')
+                           default=None,
+                           type=str,
+                           help='set password for new and updated users')
     argparser.add_argument('-V', '--verbose',
-        action='store_true',
-        help='show all students in database')
+                           action='store_true',
+                           help='show all students in database')
     return argparser.parse_args()
@@ -104,7 +104,7 @@ def insert_students_into_db(session, students):
     try:
         # --- start db session ---
         session.add_all([Student(id=s['uid'], name=s['name'], password=s['pw'])
-            for s in students])
+                        for s in students])
         session.commit()
@@ -117,7 +117,7 @@ def insert_students_into_db(session, students):
 def show_students_in_database(session, verbose=False):
     try:
         users = session.query(Student).order_by(Student.id).all()
-    except:
+    except Exception:
         raise
     else:
         n = len(users)
@@ -191,5 +191,5 @@ def main():
 # ===========================================================================
-if __name__=='__main__':
+if __name__ == '__main__':
     main()
 # python standard library
 import random
-from  datetime import datetime
+from datetime import datetime
 import logging
 # libraries
@@ -13,6 +13,7 @@ import networkx as nx
 # setup logger for this module
 logger = logging.getLogger(__name__)
+
 # ----------------------------------------------------------------------------
 # kowledge state of each student....??
 # Contains:
@@ -25,16 +26,15 @@ class StudentKnowledge(object):
     # methods that update state
     # =======================================================================
     def __init__(self, deps, factory, state={}):
-        self.deps = deps  # dependency graph shared among students
+        self.deps = deps        # shared dependency graph
         self.factory = factory  # question factory
-        self.state = state # {'topic': {'level':0.5, 'date': datetime}, ...}
+        self.state = state  # {'topic': {'level': 0.5, 'date': datetime}, ...}
         self.update_topic_levels()  # applies forgetting factor
-        self.topic_sequence = self.recommend_topic_sequence() # ['a', 'b', ...]
-        self.unlock_topics() # whose dependencies have been completed
+        self.topic_sequence = self.recommend_topic_sequence()  # ['ref1', ...]
+        self.unlock_topics()        # whose dependencies have been completed
         self.current_topic = None
-
     # ------------------------------------------------------------------------
     # Updates the proficiency levels of the topics, with forgetting factor
     # FIXME no dependencies are considered yet...
@@ -45,7 +45,6 @@ class StudentKnowledge(object):
             dt = now - s['date']
             s['level'] *= 0.95 ** dt.days   # forgetting factor 0.95 FIXME
-
     # ------------------------------------------------------------------------
     # Unlock topics whose dependencies are satisfied (> min_level)
     # ------------------------------------------------------------------------
@@ -57,15 +56,15 @@ class StudentKnowledge(object):
         for topic in self.topic_sequence:
             if topic not in self.state:  # if locked
                 pred = self.deps.predecessors(topic)
-                if all(d in self.state and self.state[d]['level'] > min_level for d in pred):
-                    # all dependencies are done
+                if all(d in self.state and self.state[d]['level'] > min_level
+                   for d in pred):  # all dependencies are done
+
                     self.state[topic] = {
                         'level': 0.0,           # unlocked
                         'date': datetime.now()
                         }
                     logger.debug(f'Unlocked "{topic}".')
-
     # ------------------------------------------------------------------------
     # Start a new topic.
     #    questions: list of generated questions to do in the topic
@@ -74,6 +73,8 @@ class StudentKnowledge(object):
     # FIXME async mas nao tem awaits...
     async def start_topic(self, topic):
         logger.debug(f'StudentKnowledge.start_topic({topic})')
+        if self.current_topic == topic:
+            return False
         # do not allow locked topics
         if self.is_locked(topic):
@@ -94,8 +95,8 @@ class StudentKnowledge(object):
         logger.debug(f'Questions: {", ".join(questions)}')
         # generate instances of questions
-        gen = lambda qref: self.factory[qref].generate()
-        self.questions = [gen(qref) for qref in questions]
+        # gen = lambda qref: self.factory[qref].generate()
+        self.questions = [self.factory[qref].generate() for qref in questions]
         # self.questions = [gen(qref) for qref in questions]
         logger.debug(f'Total: {len(self.questions)} questions')
@@ -103,7 +104,6 @@ class StudentKnowledge(object):
         self.next_question()
         return True
-
     # ------------------------------------------------------------------------
     # The topic has finished and there are no more questions.
     # The topic level is updated in state and unlocks are performed.
@@ -114,11 +114,11 @@ class StudentKnowledge(object):
         self.state[self.current_topic] = {
             'date': datetime.now(),
-            'level': self.correct_answers / (self.correct_answers + self.wrong_answers)
+            'level': self.correct_answers / (self.correct_answers +
+                                             self.wrong_answers)
             }
         self.unlock_topics()
-
     # ------------------------------------------------------------------------
     # corrects current question with provided answer.
     # implements the logic:
@@ -143,21 +143,19 @@ class StudentKnowledge(object):
         else:
             self.wrong_answers += 1
             self.current_question['tries'] -= 1
-            logger.debug(f'Wrong answers = {self.wrong_answers};  Tries = {self.current_question["tries"]}')
             if self.current_question['tries'] > 0:
                 action = 'try_again'
             else:
                 action = 'wrong'
                 if self.current_question['append_wrong']:
-                    logger.debug("Appending new instance of this question to the end")
+                    logger.debug("Append new instance of question at the end")
                     self.questions.append(self.factory[q['ref']].generate())
                 self.next_question()
         # returns corrected question (not new one) which might include comments
         return q, action
-
     # ------------------------------------------------------------------------
     # Move to next question
     # ------------------------------------------------------------------------
@@ -170,7 +168,8 @@ class StudentKnowledge(object):
         else:
             self.current_question['start_time'] = datetime.now()
             default_maxtries = self.deps.nodes[self.current_topic]['max_tries']
-            self.current_question['tries'] = self.current_question.get('max_tries', default_maxtries)
+            maxtries = self.current_question.get('max_tries', default_maxtries)
+            self.current_question['tries'] = maxtries
             logger.debug(f'Next question is "{self.current_question["ref"]}"')
         return self.current_question  # question or None
@@ -185,9 +184,21 @@ class StudentKnowledge(object):
     # ------------------------------------------------------------------------
     # compute recommended sequence of topics  ['a', 'b', ...]
     # ------------------------------------------------------------------------
-    def recommend_topic_sequence(self):
+    def recommend_topic_sequence(self, target=None):
         return list(nx.topological_sort(self.deps))
+    #     if target is None:
+    #         target = list(nx.topological_sort(self.deps))[-1]
+
+    #     weights = {}
+    #     tseq = [target]
+
+    # def topic_weights(d, g, n):
+    #     pred = g.predecessors(n)
+    #     for p in pred:
+    #         topic_weights(d, g, p)
+    #     d[n] = 1 + sum(d[m])
+
     # ------------------------------------------------------------------------
     def get_current_question(self):
         return self.current_question
@@ -212,11 +223,12 @@ class StudentKnowledge(object):
             'type': self.deps.nodes[ref]['type'],
             'name': self.deps.nodes[ref]['name'],
             'level': self.state[ref]['level'] if ref in self.state else None
-            } for ref in self.topic_sequence ]
+            } for ref in self.topic_sequence]
     # ------------------------------------------------------------------------
     def get_topic_progress(self):
-        return self.correct_answers / (1 + self.correct_answers + len(self.questions))
+        return self.correct_answers / (1 + self.correct_answers +
+                                       len(self.questions))
     # ------------------------------------------------------------------------
     def get_topic_level(self, topic):
@@ -231,4 +243,3 @@ class StudentKnowledge(object):
     # ------------------------------------------------------------------------
     # def get_recommended_topic(self):    # FIXME untested
     #     return min(self.state.items(), key=lambda x: x[1]['level'])[0]
-
@@ -28,7 +28,8 @@ logger = logging.getLogger(__name__)
 async def _bcrypt_hash(a, b):
     # loop = asyncio.get_running_loop()   # FIXME python 3.7 only
     loop = asyncio.get_event_loop()
-    return await loop.run_in_executor(None, bcrypt.hashpw, a.encode('utf-8'), b)
+    return await loop.run_in_executor(None, bcrypt.hashpw,
+                                      a.encode('utf-8'), b)
 async def check_password(try_pw, pw):
@@ -77,7 +78,9 @@ class LearnApp(object):
     async def login(self, uid, try_pw):
         with self.db_session() as s:
             try:
-                name, password = s.query(Student.name, Student.password).filter_by(id=uid).one()
+                name, password = s.query(Student.name, Student.password) \
+                                 .filter_by(id=uid) \
+                                 .one()
             except Exception:
                 logger.info(f'User "{uid}" does not exist')
                 return False
@@ -103,7 +106,8 @@ class LearnApp(object):
             self.online[uid] = {
                 'number': uid,
                 'name': name,
-                'state': StudentKnowledge(deps=self.deps, factory=self.factory, state=state),
+                'state': StudentKnowledge(deps=self.deps, factory=self.factory,
+                                          state=state),
                 'counter': counter + 1,  # counts simultaneous logins
                 }
@@ -162,14 +166,17 @@ class LearnApp(object):
             date = str(knowledge.get_topic_date(topic))
             with self.db_session() as s:
-                a = s.query(StudentTopic).filter_by(student_id=uid, topic_id=topic).one_or_none()
+                a = s.query(StudentTopic) \
+                    .filter_by(student_id=uid, topic_id=topic) \
+                    .one_or_none()
                 if a is None:
                     # insert new studenttopic into database
                     logger.debug('Database insert new studenttopic')
                     t = s.query(Topic).get(topic)
                     u = s.query(Student).get(uid)
                     # association object
-                    a = StudentTopic(level=level, date=date, topic=t, student=u)
+                    a = StudentTopic(level=level, date=date, topic=t,
+                                     student=u)
                     u.topics.append(a)
                 else:
                     # update studenttopic in database
@@ -204,7 +211,7 @@ class LearnApp(object):
             missing_topics = [Topic(id=t) for t in topics if t not in dbtopics]
             if missing_topics:
                 s.add_all(missing_topics)
-                logger.info(f'Added {len(missing_topics)} new topics to the database')
+                logger.info(f'Added {len(missing_topics)} new topics')
     # ------------------------------------------------------------------------
     # setup and check database
@@ -262,7 +269,8 @@ class LearnApp(object):
             t['file'] = attr.get('file', default_file)        # questions.yaml
             t['shuffle'] = attr.get('shuffle', default_shuffle)
             t['max_tries'] = attr.get('max_tries', default_maxtries)
-            t['forgetting_factor'] = attr.get('forgetting_factor', default_forgetting_factor)
+            t['forgetting_factor'] = attr.get('forgetting_factor',
+                                              default_forgetting_factor)
             t['choose'] = attr.get('choose', default_choose)
             t['append_wrong'] = attr.get('append_wrong', default_append_wrong)
             t['questions'] = attr.get('questions', [])
@@ -347,10 +355,6 @@ class LearnApp(object):
     def get_topic_name(self, ref):
         return self.deps.node[ref]['name']
-    # # ------------------------------------------------------------------------
-    # def get_topic_type(self, ref):
-    #     return self.deps.node[ref]['type']
-
     # ------------------------------------------------------------------------
     def get_current_public_dir(self, uid):
         topic = self.online[uid]['state'].get_current_topic()
-# FIXME see https://stackoverflow.com/questions/38248415/many-to-many-with-association-object-and-all-relationships-defined-crashes-on-de
-# And fix the association StudentTopic etc
-
-
-from sqlalchemy import Table, Column, ForeignKey, Integer, Float, String, DateTime
+from sqlalchemy import Column, ForeignKey, Integer, Float, String
 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.orm import relationship
@@ -12,13 +8,14 @@ from sqlalchemy.orm import relationship
 #   Declare ORM
 Base = declarative_base()
+
 # ---------------------------------------------------------------------------
 class StudentTopic(Base):
     __tablename__ = 'studenttopic'
     student_id = Column(String, ForeignKey('students.id'), primary_key=True)
     topic_id = Column(String, ForeignKey('topics.id'), primary_key=True)
     level = Column(Float)
-    date  = Column(String)
+    date = Column(String)
     # ---
     student = relationship('Student', back_populates='topics')
@@ -31,6 +28,7 @@ class StudentTopic(Base):
             level:      "{self.level}"
             date:       "{self.date}"'''
+
 # ---------------------------------------------------------------------------
 # Registered students
 # ---------------------------------------------------------------------------
@@ -50,12 +48,13 @@ class Student(Base):
             name:       "{self.name}"
             password:   "{self.password}"'''
+
 # ---------------------------------------------------------------------------
 # Table with every answer given
 # ---------------------------------------------------------------------------
 class Answer(Base):
     __tablename__ = 'answers'
-    id = Column(Integer, primary_key=True) # auto_increment
+    id = Column(Integer, primary_key=True)  # auto_increment
     ref = Column(String)
     grade = Column(Float)
     starttime = Column(String)
@@ -77,6 +76,7 @@ class Answer(Base):
             student_id: "{self.student_id}"
             topic_id:   "{self.topic_id}"'''
+
 # ---------------------------------------------------------------------------
 # Table with student state
 # ---------------------------------------------------------------------------
@@ -43,12 +43,12 @@ class Question(dict):
             'files': {},
             })
-    def correct(self):
+    def correct(self) -> float:
         self['comments'] = ''
         self['grade'] = 0.0
         return 0.0
-    async def correct_async(self):
+    async def correct_async(self) -> float:
         # loop = asyncio.get_running_loop()  # FIXME python 3.7 only
         loop = asyncio.get_event_loop()
         grade = await loop.run_in_executor(None, self.correct)
@@ -56,7 +56,7 @@ class Question(dict):
     def set_defaults(self, d):
         'Add k:v pairs from default dict d for nonexistent keys'
-        for k,v in d.items():
+        for k, v in d.items():
             self.setdefault(k, v)
@@ -73,7 +73,7 @@ class QuestionRadio(Question):
         choose (int)  # only used if shuffle=True
     '''
-    #------------------------------------------------------------------------
+    # ------------------------------------------------------------------------
     def __init__(self, q):
         super().__init__(q)
@@ -90,7 +90,8 @@ class QuestionRadio(Question):
         # always convert to list, e.g.  correct: 2 --> correct: [0,0,1,0,0]
         # correctness levels from 0.0 to 1.0 (no discount here!)
         if isinstance(self['correct'], int):
-            self['correct'] = [1.0 if x==self['correct'] else 0.0 for x in range(n)]
+            self['correct'] = [1.0 if x == self['correct'] else 0.0
+                               for x in range(n)]
         if self['shuffle']:
             # separate right from wrong options
@@ -101,8 +102,8 @@ class QuestionRadio(Question):
             # choose 1 correct option
             r = random.choice(right)
-            options = [ self['options'][r] ]
-            correct = [ 1.0 ]
+            options = [self['options'][r]]
+            correct = [1.0]
             # choose remaining wrong options
             random.shuffle(wrong)
@@ -112,10 +113,10 @@ class QuestionRadio(Question):
             # final shuffle of the options
             perm = random.sample(range(self['choose']), self['choose'])
-            self['options'] = [ str(options[i]) for i in perm ]
-            self['correct'] = [ float(correct[i]) for i in perm ]
+            self['options'] = [str(options[i]) for i in perm]
+            self['correct'] = [float(correct[i]) for i in perm]
-    #------------------------------------------------------------------------
+    # ------------------------------------------------------------------------
     # can return negative values for wrong answers
     def correct(self):
         super().correct()
@@ -144,7 +145,7 @@ class QuestionCheckbox(Question):
         answer (None or an actual answer)
     '''
-    #------------------------------------------------------------------------
+    # ------------------------------------------------------------------------
     def __init__(self, q):
         super().__init__(q)
@@ -153,24 +154,25 @@ class QuestionCheckbox(Question):
         # set defaults if missing
         self.set_defaults({
             'text': '',
-            'correct': [1.0] * n,     # Using 0.0 breaks the (right, wrong) options
+            'correct': [1.0] * n,     # Using 0.0 breaks (right, wrong) options
             'shuffle': True,
             'discount': True,
             'choose': n,              # number of options
             })
         if len(self['correct']) != n:
-            logger.error(f'Options and correct size mismatch in "{self["ref"]}", file "{self["filename"]}".')
+            logger.error(f'Options and correct size mismatch in '
+                         f'"{self["ref"]}", file "{self["filename"]}".')
         # if an option is a list of (right, wrong), pick one
         # FIXME it's possible that all options are chosen wrong
         options = []
         correct = []
-        for o,c in zip(self['options'], self['correct']):
+        for o, c in zip(self['options'], self['correct']):
             if isinstance(o, list):
-                r = random.randint(0,1)
+                r = random.randint(0, 1)
                 o = o[r]
-                c = c if r==0 else -c
+                c = c if r == 0 else -c
             options.append(str(o))
             correct.append(float(c))
@@ -181,7 +183,7 @@ class QuestionCheckbox(Question):
             self['options'] = [options[i] for i in perm]
             self['correct'] = [correct[i] for i in perm]
-    #------------------------------------------------------------------------
+    # ------------------------------------------------------------------------
     # can return negative values for wrong answers
     def correct(self):
         super().correct()
@@ -215,7 +217,7 @@ class QuestionText(Question):
         answer (None or an actual answer)
     '''
-    #------------------------------------------------------------------------
+    # ------------------------------------------------------------------------
     def __init__(self, q):
         super().__init__(q)
@@ -231,7 +233,7 @@ class QuestionText(Question):
         # make sure all elements of the list are strings
         self['correct'] = [str(a) for a in self['correct']]
-    #------------------------------------------------------------------------
+    # ------------------------------------------------------------------------
     # can return negative values for wrong answers
     def correct(self):
         super().correct()
@@ -251,7 +253,7 @@ class QuestionTextRegex(Question):
         answer (None or an actual answer)
     '''
-    #------------------------------------------------------------------------
+    # ------------------------------------------------------------------------
     def __init__(self, q):
         super().__init__(q)
@@ -260,15 +262,17 @@ class QuestionTextRegex(Question):
             'correct': '$.^',   # will always return false
             })
-    #------------------------------------------------------------------------
+    # ------------------------------------------------------------------------
     # can return negative values for wrong answers
     def correct(self):
         super().correct()
         if self['answer'] is not None:
             try:
-                self['grade'] = 1.0 if re.match(self['correct'], self['answer']) else 0.0
+                ok = re.match(self['correct'], self['answer'])
             except TypeError:
-                logger.error('While matching regex {self["correct"]} with answer {self["answer"]}.')
+                logger.error(f'While matching regex {self["correct"]} with '
+                             f'answer {self["answer"]}.')
+            self['grade'] = 1.0 if ok else 0.0
         return self['grade']
@@ -283,7 +287,7 @@ class QuestionNumericInterval(Question):
     An answer is correct if it's in the closed interval.
     '''
-    #------------------------------------------------------------------------
+    # ------------------------------------------------------------------------
     def __init__(self, q):
         super().__init__(q)
@@ -292,7 +296,7 @@ class QuestionNumericInterval(Question):
             'correct': [1.0, -1.0],   # will always return false
             })
-    #------------------------------------------------------------------------
+    # ------------------------------------------------------------------------
     # can return negative values for wrong answers
     def correct(self):
         super().correct()
@@ -302,7 +306,8 @@ class QuestionNumericInterval(Question):
             try:         # replace , by . and convert to float
                 answer = float(self['answer'].replace(',', '.', 1))
             except ValueError:
-                self['comments'] = 'A resposta tem de ser numérica, por exemplo 12.345.'
+                self['comments'] = ('A resposta tem de ser numérica, '
+                                    'por exemplo 12.345.')
                 self['grade'] = 0.0
             else:
                 self['grade'] = 1.0 if lower <= answer <= upper else 0.0
@@ -320,7 +325,7 @@ class QuestionTextArea(Question):
         lines (int)
     '''
-    #------------------------------------------------------------------------
+    # ------------------------------------------------------------------------
     def __init__(self, q):
         super().__init__(q)
@@ -331,10 +336,9 @@ class QuestionTextArea(Question):
             'correct': ''  # trying to execute this will fail => grade 0.0
             })
-        # self['correct'] = path.join(self['path'], self['correct'])
-        self['correct'] = path.abspath(path.normpath(path.join(self['path'], self['correct'])))
+        self['correct'] = path.join(self['path'], self['correct'])   # FIXME
-    #------------------------------------------------------------------------
+    # ------------------------------------------------------------------------
     # can return negative values for wrong answers
     def correct(self):
         super().correct()
@@ -347,31 +351,30 @@ class QuestionTextArea(Question):
                 timeout=self['timeout']
                 )
-            if type(out) in (int, float):
-                self['grade'] = float(out)
-
-            elif isinstance(out, dict):
+            if isinstance(out, dict):
                 self['comments'] = out.get('comments', '')
                 try:
                     self['grade'] = float(out['grade'])
                 except ValueError:
-                    logger.error(f'Correction script of "{self["ref"]}" returned nonfloat.')
+                    logger.error(f'Output error in "{self["correct"]}".')
                 except KeyError:
-                    logger.error('Correction script of "{self["ref"]}" returned no "grade".')
+                    logger.error(f'No grade in "{self["correct"]}".')
+            else:
+                self['grade'] = float(out)
         return self['grade']
 # ===========================================================================
 class QuestionInformation(Question):
-    #------------------------------------------------------------------------
+    # ------------------------------------------------------------------------
     def __init__(self, q):
         super().__init__(q)
         self.set_defaults({
             'text': '',
             })
-    #------------------------------------------------------------------------
+    # ------------------------------------------------------------------------
     # can return negative values for wrong answers
     def correct(self):
         super().correct()
@@ -4,6 +4,7 @@ from tornado.web import RedirectHandler, Application
 from tornado.ioloop import IOLoop
 import argparse
+
 def main():
     default_url = 'https://bit.xdi.uevora.pt/'
     default_port = 8080
@@ -381,7 +381,8 @@ def parse_cmdline_arguments():
     return argparser.parse_args()
-# -------------------------------------------------------------------------
+
+# ----------------------------------------------------------------------------
 def get_logger_config(debug=False):
     if debug:
         filename = 'logger-debug.yaml'
@@ -397,7 +398,8 @@ def get_logger_config(debug=False):
         'version': 1,
         'formatters': {
             'standard': {
-                'format': '%(asctime)s %(name)-24s %(levelname)-8s %(message)s',
+                'format': '%(asctime)s %(name)-24s %(levelname)-8s '
+                          '%(message)s',
                 'datefmt': '%H:%M:%S',
                 },
             },
@@ -23,11 +23,13 @@ logger = logging.getLogger(__name__)
 # -------------------------------------------------------------------------
 class MathBlockGrammar(mistune.BlockGrammar):
     block_math = re.compile(r'^\$\$(.*?)\$\$', re.DOTALL)
-    latex_environment = re.compile(r'^\\begin\{([a-z]*\*?)\}(.*?)\\end\{\1\}', re.DOTALL)
+    latex_environment = re.compile(r'^\\begin\{([a-z]*\*?)\}(.*?)\\end\{\1\}',
+                                   re.DOTALL)
 class MathBlockLexer(mistune.BlockLexer):
-    default_rules = ['block_math', 'latex_environment'] + mistune.BlockLexer.default_rules
+    default_rules = ['block_math', 'latex_environment'] \
+                    + mistune.BlockLexer.default_rules
     def __init__(self, rules=None, **kwargs):
         if rules is None:
@@ -82,27 +84,29 @@ class MarkdownWithMath(mistune.Markdown):
         return self.renderer.block_math(self.token['text'])
     def output_latex_environment(self):
-        return self.renderer.latex_environment(self.token['name'], self.token['text'])
-
+        return self.renderer.latex_environment(self.token['name'],
+                                               self.token['text'])
 class HighlightRenderer(mistune.Renderer):
     def block_code(self, code, lang='text'):
         try:
             lexer = get_lexer_by_name(lang, stripall=False)
-        except:
+        except Exception:
             lexer = get_lexer_by_name('text', stripall=False)
         formatter = HtmlFormatter()
         return highlight(code, lexer, formatter)
     def table(self, header, body):
-        return '<table class="table table-sm"><thead class="thead-light">' + header + '</thead><tbody>' + body + "</tbody></table>"
+        return '<table class="table table-sm"><thead class="thead-light">' \
+               + header + '</thead><tbody>' + body + "</tbody></table>"
     def image(self, src, title, alt):
         alt = mistune.escape(alt, quote=True)
         title = mistune.escape(title or '', quote=True)
-        return f'<img src="/file/{src}" class="img-fluid mx-auto d-block" alt="{alt}" title="{title}">'
+        return f'<img src="/file/{src}" class="img-fluid mx-auto d-block" ' \
+               f'alt="{alt}" title="{title}">'
     # Pass math through unaltered - mathjax does the rendering in the browser
     def block_math(self, text):
@@ -115,7 +119,9 @@ class HighlightRenderer(mistune.Renderer):
         return fr'$$$ {text} $$$'
-markdown = MarkdownWithMath(HighlightRenderer(escape=True)) # hard_wrap=True to insert <br> on newline
+# hard_wrap=True to insert <br> on newline
+markdown = MarkdownWithMath(HighlightRenderer(escape=True))
+
 def md_to_html(text, strip_p_tag=False, q=None):
     md = markdown(text)
@@ -124,6 +130,7 @@ def md_to_html(text, strip_p_tag=False, q=None):
     else:
         return md
+
 # ---------------------------------------------------------------------------
 # load data from yaml file
 # ---------------------------------------------------------------------------
@@ -143,10 +150,12 @@ def load_yaml(filename, default=None):
                 default = yaml.load(f)
             except yaml.YAMLError as e:
                 mark = e.problem_mark
-                logger.error(f'In YAML file "{filename}" near line {mark.line}, column {mark.column+1}')
+                logger.error(f'In file "{filename}" near line {mark.line}, '
+                             f'column {mark.column+1}')
     finally:
         return default
+
 # ---------------------------------------------------------------------------
 # Runs a script and returns its stdout parsed as yaml, or None on error.
 # The script is run in another process but this function blocks waiting
@@ -156,27 +165,27 @@ def run_script(script, stdin=&#39;&#39;, timeout=5):
     script = path.expanduser(script)
     try:
         p = subprocess.run([script],
-            input=stdin,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-            universal_newlines=True,
-            timeout=timeout,
-            )
+                           input=stdin,
+                           stdout=subprocess.PIPE,
+                           stderr=subprocess.STDOUT,
+                           universal_newlines=True,
+                           timeout=timeout,
+                           )
     except FileNotFoundError:
-        logger.error(f'Could not execute script "{script}": not found.')
+        logger.error(f'Can not execute script "{script}": not found.')
     except PermissionError:
-        logger.error(f'Could not execute script "{script}": wrong permissions.')
+        logger.error(f'Can not execute script "{script}": wrong permissions.')
     except OSError:
-        logger.error(f'Could not execute script "{script}": unknown reason.')
+        logger.error(f'Can not execute script "{script}": unknown reason.')
     except subprocess.TimeoutExpired:
-        logger.error(f'Timeout exceeded ({timeout}s) while running "{script}".')
+        logger.error(f'Timeout {timeout}s exceeded while running "{script}".')
     else:
         if p.returncode != 0:
-            logger.error(f'Script "{script}" returned error code {p.returncode}.')
+            logger.error(f'Return code {p.returncode} running "{script}".')
         else:
             try:
                 output = yaml.load(p.stdout)
-            except:
+            except Exception:
                 logger.error(f'Error parsing yaml output of "{script}"')
             else:
                 return output
@@ -9,19 +9,19 @@ s = sys.stdin.read()
 answer = set(re.findall(r'[\w]+', s.lower()))
 answer.difference_update({'e', 'a', 'planeta', 'planetas'})  # ignore these
-# correct set of colors
-planets = set(['mercúrio', 'vénus', 'terra'])
+# correct set of planets
+planets = {'mercúrio', 'vénus', 'terra'}
-correct = set.intersection(answer, planets) # os que acertei
-wrong = set.difference(answer, planets)   # os que errei
-# allnames = set.union(answer, planets)
+correct = set.intersection(answer, planets)     # the ones I got right
+wrong = set.difference(answer, planets)         # the ones I got wrong
 grade = (len(correct) - len(wrong)) / len(planets)
-out = f'grade: {grade}'
+out = f'''---
+grade: {grade}'''
 if grade < 1.0:
-    out += '\ncomments: A resposta correcta é `Mercúrio, Vénus e Terra`.'
+    out += '\ncomments: Vou dar uma ajuda, as iniciais são M, V e T...'
 print(out)
-exit(0)
 \ No newline at end of file
+exit(0)
	@@ -4,6 +4,7 @@ from tornado.web import RedirectHandler, Application		@@ -4,6 +4,7 @@ from tornado.web import RedirectHandler, Application
4	from tornado.ioloop import IOLoop	4	from tornado.ioloop import IOLoop
5	import argparse	5	import argparse
6		6
		7	+
7	def main():	8	def main():
8	default_url = 'https://bit.xdi.uevora.pt/'	9	default_url = 'https://bit.xdi.uevora.pt/'
9	default_port = 8080	10	default_port = 8080