code cleaning and refactoring.

changed filename knowledge.py to student.py

code cleaning and refactoring.
changed filename knowledge.py to student.py
Miguel Barão
1 parent 88531302
Showing 4 changed files with 248 additions and 248 deletions Show diff stats
aprendizations/__init__.py
aprendizations/knowledge.py
aprendizations/learnapp.py
aprendizations/student.py
@@ -30,7 +30,7 @@ are progressively uncovered as the students progress.
 '''
 APP_NAME = 'aprendizations'
-APP_VERSION = '2019.05.dev3'
+APP_VERSION = '2019.07.dev1'
 APP_DESCRIPTION = __doc__
 __author__ = 'Miguel Barão'
@@ -1,236 +0,0 @@
-
-# python standard library
-import random
-from datetime import datetime
-import logging
-
-# third party libraries
-import networkx as nx
-
-# setup logger for this module
-logger = logging.getLogger(__name__)
-
-
-# ----------------------------------------------------------------------------
-# kowledge state of each student....??
-# Contains:
-#   state - dict of topics with state of unlocked topics
-#   deps  - access to dependency graph shared between students
-#   topic_sequence - list with the order of recommended topics
-# ----------------------------------------------------------------------------
-class StudentKnowledge(object):
-    # =======================================================================
-    # methods that update state
-    # =======================================================================
-    def __init__(self, deps, factory, state={}):
-        self.deps = deps        # shared dependency graph
-        self.factory = factory  # question factory
-        self.state = state  # {'topic': {'level': 0.5, 'date': datetime}, ...}
-
-        self.update_topic_levels()  # applies forgetting factor
-        self.unlock_topics()        # whose dependencies have been completed
-        self.topic_sequence = self.recommend_topic_sequence()  # ['ref1', ...]
-        self.current_topic = None
-
-    # ------------------------------------------------------------------------
-    # Updates the proficiency levels of the topics, with forgetting factor
-    # FIXME no dependencies are considered yet...
-    # ------------------------------------------------------------------------
-    def update_topic_levels(self):
-        now = datetime.now()
-        for tref, s in self.state.items():
-            dt = now - s['date']
-            s['level'] *= 0.98 ** dt.days   # forgetting factor
-
-    # ------------------------------------------------------------------------
-    # Unlock topics whose dependencies are satisfied (> min_level)
-    # ------------------------------------------------------------------------
-    def unlock_topics(self):
-        for topic in self.deps.nodes():
-            if topic not in self.state:  # if locked
-                pred = self.deps.predecessors(topic)
-                min_level = self.deps.node[topic]['min_level']
-                if all(d in self.state and self.state[d]['level'] > min_level
-                   for d in pred):  # all deps are greater than min_level
-
-                    self.state[topic] = {
-                        'level': 0.0,           # unlocked
-                        'date': datetime.now()
-                        }
-                    logger.debug(f'[unlock_topics] Unlocked "{topic}".')
-                # else:  # lock this topic if deps do not satisfy min_level
-                #     del self.state[topic]
-
-    # ------------------------------------------------------------------------
-    # Start a new topic.
-    #    questions: list of generated questions to do in the topic
-    #    current_question: the current question to be presented
-    # ------------------------------------------------------------------------
-    async def start_topic(self, topic):
-        logger.debug(f'[start_topic] topic "{topic}"')
-
-        if self.current_topic == topic:
-            logger.info('Restarting current topic is not allowed.')
-            return
-
-        # do not allow locked topics
-        if self.is_locked(topic):
-            logger.debug(f'[start_topic] topic "{topic}" is locked')
-            return
-
-        # starting new topic
-        self.current_topic = topic
-        self.correct_answers = 0
-        self.wrong_answers = 0
-
-        t = self.deps.node[topic]
-        k = t['choose']
-        if t['shuffle_questions']:
-            questions = random.sample(t['questions'], k=k)
-        else:
-            questions = t['questions'][:k]
-        logger.debug(f'[start_topic] questions: {", ".join(questions)}')
-
-        # synchronous
-        # self.questions = [self.factory[ref].generate()
-        #                   for ref in questions]
-
-        # asynchronous:
-        self.questions = [await self.factory[ref].generate_async()
-                          for ref in questions]
-
-        n = len(self.questions)
-        logger.debug(f'[start_topic] generated {n} questions')
-
-        # get first question
-        self.next_question()
-
-    # ------------------------------------------------------------------------
-    # The topic has finished and there are no more questions.
-    # The topic level is updated in state and unlocks are performed.
-    # The current topic is unchanged.
-    # ------------------------------------------------------------------------
-    def finish_topic(self):
-        logger.debug(f'[finish_topic] current_topic {self.current_topic}')
-
-        self.state[self.current_topic] = {
-            'date': datetime.now(),
-            'level': self.correct_answers / (self.correct_answers +
-                                             self.wrong_answers)
-            }
-        # self.current_topic = None
-        self.unlock_topics()
-
-    # ------------------------------------------------------------------------
-    # corrects current question with provided answer.
-    # implements the logic:
-    #   - if answer ok, goes to next question
-    #   - if wrong, counts number of tries. If exceeded, moves on.
-    # ------------------------------------------------------------------------
-    async def check_answer(self, answer):
-        logger.debug('[check_answer]')
-
-        q = self.current_question
-        q['answer'] = answer
-        q['finish_time'] = datetime.now()
-        await q.correct_async()
-        logger.debug(f'[check_answer] Grade {q["grade"]:.2} in {q["ref"]}')
-
-        if q['grade'] > 0.999:
-            self.correct_answers += 1
-            self.next_question()
-            action = 'right'
-
-        else:
-            self.wrong_answers += 1
-            self.current_question['tries'] -= 1
-
-            if self.current_question['tries'] > 0:
-                action = 'try_again'
-            else:
-                action = 'wrong'
-                if self.current_question['append_wrong']:
-                    logger.debug('[check_answer] Wrong, append new instance')
-                    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
-    # ------------------------------------------------------------------------
-    def next_question(self):
-        try:
-            self.current_question = self.questions.pop(0)
-        except IndexError:
-            self.current_question = None
-            self.finish_topic()
-        else:
-            self.current_question['start_time'] = datetime.now()
-            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] "{self.current_question["ref"]}"')
-
-        return self.current_question  # question or None
-
-    # ========================================================================
-    # pure functions of the state (no side effects)
-    # ========================================================================
-
-    def topic_has_finished(self):
-        return self.current_question is None
-
-    # ------------------------------------------------------------------------
-    # compute recommended sequence of topics  ['a', 'b', ...]
-    # ------------------------------------------------------------------------
-    def recommend_topic_sequence(self, target=None):
-        tt = list(nx.topological_sort(self.deps))
-        unlocked = [t for t in tt if t in self.state]
-        locked = [t for t in tt if t not in unlocked]
-        return unlocked + locked
-
-    # ------------------------------------------------------------------------
-    def get_current_question(self):
-        return self.current_question
-
-    # ------------------------------------------------------------------------
-    def get_current_topic(self):
-        return self.current_topic
-
-    # ------------------------------------------------------------------------
-    def is_locked(self, topic):
-        return topic not in self.state
-
-    # ------------------------------------------------------------------------
-    # Return list of {ref: 'xpto', name: 'long name', leve: 0.5}
-    # Levels are in the interval [0, 1] if unlocked or None if locked.
-    # Topics unlocked but not yet done have level 0.0.
-    # ------------------------------------------------------------------------
-    def get_knowledge_state(self):
-        return [{
-            'ref': ref,
-            '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]
-
-    # ------------------------------------------------------------------------
-    def get_topic_progress(self):
-        return self.correct_answers / (1 + self.correct_answers +
-                                       len(self.questions))
-
-    # ------------------------------------------------------------------------
-    def get_topic_level(self, topic):
-        return self.state[topic]['level']
-
-    # ------------------------------------------------------------------------
-    def get_topic_date(self, topic):
-        return self.state[topic]['date']
-
-    # ------------------------------------------------------------------------
-    # Recommends a topic to practice/learn from the state.
-    # ------------------------------------------------------------------------
-    # def get_recommended_topic(self):    # FIXME untested
-    #     return min(self.state.items(), key=lambda x: x[1]['level'])[0]
@@ -15,7 +15,7 @@ import networkx as nx
 # this project
 from .models import Student, Answer, Topic, StudentTopic
-from .knowledge import StudentKnowledge
+from .student import StudentState
 from .questions import QFactory
 from .tools import load_yaml
@@ -155,8 +155,8 @@ class LearnApp(object):
             self.online[uid] = {
                 'number': uid,
                 'name': name,
-                'state': StudentKnowledge(deps=self.deps, factory=self.factory,
-                                          state=state),
+                'state': StudentState(deps=self.deps, factory=self.factory,
+                                      state=state),
                 'counter': counter + 1,  # counts simultaneous logins
                 }
@@ -441,16 +441,16 @@ class LearnApp(object):
             total_topics = s.query(Topic).count()
             # answer performance
-            totalans = dict(s.query(Answer.student_id, sa.func.count(Answer.ref)).
-                            group_by(Answer.student_id).
-                            all())
-            rightans = dict(s.query(Answer.student_id, sa.func.count(Answer.ref)).
-                            filter(Answer.grade == 1.0).
-                            group_by(Answer.student_id).
-                            all())
+            total = dict(s.query(Answer.student_id, sa.func.count(Answer.ref)).
+                         group_by(Answer.student_id).
+                         all())
+            right = dict(s.query(Answer.student_id, sa.func.count(Answer.ref)).
+                         filter(Answer.grade == 1.0).
+                         group_by(Answer.student_id).
+                         all())
         # compute percentage of right answers
-        perf = {uid: rightans.get(uid, 0.0)/totalans[uid] for uid in totalans}
+        perf = {uid: right.get(uid, 0.0)/total[uid] for uid in total}
         # compute topic progress
         prog = {s[0]: 0.0 for s in students}
@@ -0,0 +1,236 @@
+
+# python standard library
+import random
+from datetime import datetime
+import logging
+
+# third party libraries
+import networkx as nx
+
+# setup logger for this module
+logger = logging.getLogger(__name__)
+
+
+# ----------------------------------------------------------------------------
+# kowledge state of each student....??
+# Contains:
+#   state - dict of topics with state of unlocked topics
+#   deps  - access to dependency graph shared between students
+#   topic_sequence - list with the order of recommended topics
+# ----------------------------------------------------------------------------
+class StudentState(object):
+    # =======================================================================
+    # methods that update state
+    # =======================================================================
+    def __init__(self, deps, factory, state={}):
+        self.deps = deps        # shared dependency graph
+        self.factory = factory  # question factory
+        self.state = state  # {'topic': {'level': 0.5, 'date': datetime}, ...}
+
+        self.update_topic_levels()  # applies forgetting factor
+        self.unlock_topics()        # whose dependencies have been completed
+        self.topic_sequence = self.recommend_topic_sequence()  # ['ref1', ...]
+        self.current_topic = None
+
+    # ------------------------------------------------------------------------
+    # Updates the proficiency levels of the topics, with forgetting factor
+    # FIXME no dependencies are considered yet...
+    # ------------------------------------------------------------------------
+    def update_topic_levels(self):
+        now = datetime.now()
+        for tref, s in self.state.items():
+            dt = now - s['date']
+            s['level'] *= 0.98 ** dt.days   # forgetting factor
+
+    # ------------------------------------------------------------------------
+    # Unlock topics whose dependencies are satisfied (> min_level)
+    # ------------------------------------------------------------------------
+    def unlock_topics(self):
+        for topic in self.deps.nodes():
+            if topic not in self.state:  # if locked
+                pred = self.deps.predecessors(topic)
+                min_level = self.deps.node[topic]['min_level']
+                if all(d in self.state and self.state[d]['level'] > min_level
+                   for d in pred):  # all deps are greater than min_level
+
+                    self.state[topic] = {
+                        'level': 0.0,           # unlocked
+                        'date': datetime.now()
+                        }
+                    logger.debug(f'[unlock_topics] Unlocked "{topic}".')
+                # else:  # lock this topic if deps do not satisfy min_level
+                #     del self.state[topic]
+
+    # ------------------------------------------------------------------------
+    # Start a new topic.
+    #    questions: list of generated questions to do in the topic
+    #    current_question: the current question to be presented
+    # ------------------------------------------------------------------------
+    async def start_topic(self, topic):
+        logger.debug(f'[start_topic] topic "{topic}"')
+
+        if self.current_topic == topic:
+            logger.info('Restarting current topic is not allowed.')
+            return
+
+        # do not allow locked topics
+        if self.is_locked(topic):
+            logger.debug(f'[start_topic] topic "{topic}" is locked')
+            return
+
+        # starting new topic
+        self.current_topic = topic
+        self.correct_answers = 0
+        self.wrong_answers = 0
+
+        t = self.deps.node[topic]
+        k = t['choose']
+        if t['shuffle_questions']:
+            questions = random.sample(t['questions'], k=k)
+        else:
+            questions = t['questions'][:k]
+        logger.debug(f'[start_topic] questions: {", ".join(questions)}')
+
+        # synchronous
+        # self.questions = [self.factory[ref].generate()
+        #                   for ref in questions]
+
+        # asynchronous:
+        self.questions = [await self.factory[ref].generate_async()
+                          for ref in questions]
+
+        n = len(self.questions)
+        logger.debug(f'[start_topic] generated {n} questions')
+
+        # get first question
+        self.next_question()
+
+    # ------------------------------------------------------------------------
+    # The topic has finished and there are no more questions.
+    # The topic level is updated in state and unlocks are performed.
+    # The current topic is unchanged.
+    # ------------------------------------------------------------------------
+    def finish_topic(self):
+        logger.debug(f'[finish_topic] current_topic {self.current_topic}')
+
+        self.state[self.current_topic] = {
+            'date': datetime.now(),
+            'level': self.correct_answers / (self.correct_answers +
+                                             self.wrong_answers)
+            }
+        # self.current_topic = None
+        self.unlock_topics()
+
+    # ------------------------------------------------------------------------
+    # corrects current question with provided answer.
+    # implements the logic:
+    #   - if answer ok, goes to next question
+    #   - if wrong, counts number of tries. If exceeded, moves on.
+    # ------------------------------------------------------------------------
+    async def check_answer(self, answer):
+        logger.debug('[check_answer]')
+
+        q = self.current_question
+        q['answer'] = answer
+        q['finish_time'] = datetime.now()
+        await q.correct_async()
+        logger.debug(f'[check_answer] Grade {q["grade"]:.2} in {q["ref"]}')
+
+        if q['grade'] > 0.999:
+            self.correct_answers += 1
+            self.next_question()
+            action = 'right'
+
+        else:
+            self.wrong_answers += 1
+            self.current_question['tries'] -= 1
+
+            if self.current_question['tries'] > 0:
+                action = 'try_again'
+            else:
+                action = 'wrong'
+                if self.current_question['append_wrong']:
+                    logger.debug('[check_answer] Wrong, append new instance')
+                    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
+    # ------------------------------------------------------------------------
+    def next_question(self):
+        try:
+            self.current_question = self.questions.pop(0)
+        except IndexError:
+            self.current_question = None
+            self.finish_topic()
+        else:
+            self.current_question['start_time'] = datetime.now()
+            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] "{self.current_question["ref"]}"')
+
+        return self.current_question  # question or None
+
+    # ========================================================================
+    # pure functions of the state (no side effects)
+    # ========================================================================
+
+    def topic_has_finished(self):
+        return self.current_question is None
+
+    # ------------------------------------------------------------------------
+    # compute recommended sequence of topics  ['a', 'b', ...]
+    # ------------------------------------------------------------------------
+    def recommend_topic_sequence(self, target=None):
+        tt = list(nx.topological_sort(self.deps))
+        unlocked = [t for t in tt if t in self.state]
+        locked = [t for t in tt if t not in unlocked]
+        return unlocked + locked
+
+    # ------------------------------------------------------------------------
+    def get_current_question(self):
+        return self.current_question
+
+    # ------------------------------------------------------------------------
+    def get_current_topic(self):
+        return self.current_topic
+
+    # ------------------------------------------------------------------------
+    def is_locked(self, topic):
+        return topic not in self.state
+
+    # ------------------------------------------------------------------------
+    # Return list of {ref: 'xpto', name: 'long name', leve: 0.5}
+    # Levels are in the interval [0, 1] if unlocked or None if locked.
+    # Topics unlocked but not yet done have level 0.0.
+    # ------------------------------------------------------------------------
+    def get_knowledge_state(self):
+        return [{
+            'ref': ref,
+            '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]
+
+    # ------------------------------------------------------------------------
+    def get_topic_progress(self):
+        return self.correct_answers / (1 + self.correct_answers +
+                                       len(self.questions))
+
+    # ------------------------------------------------------------------------
+    def get_topic_level(self, topic):
+        return self.state[topic]['level']
+
+    # ------------------------------------------------------------------------
+    def get_topic_date(self, topic):
+        return self.state[topic]['date']
+
+    # ------------------------------------------------------------------------
+    # Recommends a topic to practice/learn from the state.
+    # ------------------------------------------------------------------------
+    # def get_recommended_topic(self):    # FIXME untested
+    #     return min(self.state.items(), key=lambda x: x[1]['level'])[0]
	@@ -30,7 +30,7 @@ are progressively uncovered as the students progress.		@@ -30,7 +30,7 @@ are progressively uncovered as the students progress.
30	'''	30	'''
31		31
32	APP_NAME = 'aprendizations'	32	APP_NAME = 'aprendizations'
33	-APP_VERSION = '2019.05.dev3'	33	+APP_VERSION = '2019.07.dev1'
34	APP_DESCRIPTION = __doc__	34	APP_DESCRIPTION = __doc__
35		35
36	__author__ = 'Miguel Barão'	36	__author__ = 'Miguel Barão'
	@@ -1,236 +0,0 @@	@@ -1,236 +0,0 @@
1	-
2	-# python standard library
3	-import random
4	-from datetime import datetime
5	-import logging
6	-
7	-# third party libraries
8	-import networkx as nx
9	-
10	-# setup logger for this module
11	-logger = logging.getLogger(__name__)
12	-
13	-
14	-# ----------------------------------------------------------------------------
15	-# kowledge state of each student....??
16	-# Contains:
17	-# state - dict of topics with state of unlocked topics
18	-# deps - access to dependency graph shared between students
19	-# topic_sequence - list with the order of recommended topics
20	-# ----------------------------------------------------------------------------
21	-class StudentKnowledge(object):
22	- # =======================================================================
23	- # methods that update state
24	- # =======================================================================
25	- def __init__(self, deps, factory, state={}):
26	- self.deps = deps # shared dependency graph
27	- self.factory = factory # question factory
28	- self.state = state # {'topic': {'level': 0.5, 'date': datetime}, ...}
29	-
30	- self.update_topic_levels() # applies forgetting factor
31	- self.unlock_topics() # whose dependencies have been completed
32	- self.topic_sequence = self.recommend_topic_sequence() # ['ref1', ...]
33	- self.current_topic = None
34	-
35	- # ------------------------------------------------------------------------
36	- # Updates the proficiency levels of the topics, with forgetting factor
37	- # FIXME no dependencies are considered yet...
38	- # ------------------------------------------------------------------------
39	- def update_topic_levels(self):
40	- now = datetime.now()
41	- for tref, s in self.state.items():
42	- dt = now - s['date']
43	- s['level'] = 0.98 * dt.days # forgetting factor
44	-
45	- # ------------------------------------------------------------------------
46	- # Unlock topics whose dependencies are satisfied (> min_level)
47	- # ------------------------------------------------------------------------
48	- def unlock_topics(self):
49	- for topic in self.deps.nodes():
50	- if topic not in self.state: # if locked
51	- pred = self.deps.predecessors(topic)
52	- min_level = self.deps.node[topic]['min_level']
53	- if all(d in self.state and self.state[d]['level'] > min_level
54	- for d in pred): # all deps are greater than min_level
55	-
56	- self.state[topic] = {
57	- 'level': 0.0, # unlocked
58	- 'date': datetime.now()
59	- }
60	- logger.debug(f'[unlock_topics] Unlocked "{topic}".')
61	- # else: # lock this topic if deps do not satisfy min_level
62	- # del self.state[topic]
63	-
64	- # ------------------------------------------------------------------------
65	- # Start a new topic.
66	- # questions: list of generated questions to do in the topic
67	- # current_question: the current question to be presented
68	- # ------------------------------------------------------------------------
69	- async def start_topic(self, topic):
70	- logger.debug(f'[start_topic] topic "{topic}"')
71	-
72	- if self.current_topic == topic:
73	- logger.info('Restarting current topic is not allowed.')
74	- return
75	-
76	- # do not allow locked topics
77	- if self.is_locked(topic):
78	- logger.debug(f'[start_topic] topic "{topic}" is locked')
79	- return
80	-
81	- # starting new topic
82	- self.current_topic = topic
83	- self.correct_answers = 0
84	- self.wrong_answers = 0
85	-
86	- t = self.deps.node[topic]
87	- k = t['choose']
88	- if t['shuffle_questions']:
89	- questions = random.sample(t['questions'], k=k)
90	- else:
91	- questions = t['questions'][:k]
92	- logger.debug(f'[start_topic] questions: {", ".join(questions)}')
93	-
94	- # synchronous
95	- # self.questions = [self.factory[ref].generate()
96	- # for ref in questions]
97	-
98	- # asynchronous:
99	- self.questions = [await self.factory[ref].generate_async()
100	- for ref in questions]
101	-
102	- n = len(self.questions)
103	- logger.debug(f'[start_topic] generated {n} questions')
104	-
105	- # get first question
106	- self.next_question()
107	-
108	- # ------------------------------------------------------------------------
109	- # The topic has finished and there are no more questions.
110	- # The topic level is updated in state and unlocks are performed.
111	- # The current topic is unchanged.
112	- # ------------------------------------------------------------------------
113	- def finish_topic(self):
114	- logger.debug(f'[finish_topic] current_topic {self.current_topic}')
115	-
116	- self.state[self.current_topic] = {
117	- 'date': datetime.now(),
118	- 'level': self.correct_answers / (self.correct_answers +
119	- self.wrong_answers)
120	- }
121	- # self.current_topic = None
122	- self.unlock_topics()
123	-
124	- # ------------------------------------------------------------------------
125	- # corrects current question with provided answer.
126	- # implements the logic:
127	- # - if answer ok, goes to next question
128	- # - if wrong, counts number of tries. If exceeded, moves on.
129	- # ------------------------------------------------------------------------
130	- async def check_answer(self, answer):
131	- logger.debug('[check_answer]')
132	-
133	- q = self.current_question
134	- q['answer'] = answer
135	- q['finish_time'] = datetime.now()
136	- await q.correct_async()
137	- logger.debug(f'[check_answer] Grade {q["grade"]:.2} in {q["ref"]}')
138	-
139	- if q['grade'] > 0.999:
140	- self.correct_answers += 1
141	- self.next_question()
142	- action = 'right'
143	-
144	- else:
145	- self.wrong_answers += 1
146	- self.current_question['tries'] -= 1
147	-
148	- if self.current_question['tries'] > 0:
149	- action = 'try_again'
150	- else:
151	- action = 'wrong'
152	- if self.current_question['append_wrong']:
153	- logger.debug('[check_answer] Wrong, append new instance')
154	- self.questions.append(self.factory[q['ref']].generate())
155	- self.next_question()
156	-
157	- # returns corrected question (not new one) which might include comments
158	- return q, action
159	-
160	- # ------------------------------------------------------------------------
161	- # Move to next question
162	- # ------------------------------------------------------------------------
163	- def next_question(self):
164	- try:
165	- self.current_question = self.questions.pop(0)
166	- except IndexError:
167	- self.current_question = None
168	- self.finish_topic()
169	- else:
170	- self.current_question['start_time'] = datetime.now()
171	- default_maxtries = self.deps.nodes[self.current_topic]['max_tries']
172	- maxtries = self.current_question.get('max_tries', default_maxtries)
173	- self.current_question['tries'] = maxtries
174	- logger.debug(f'[next_question] "{self.current_question["ref"]}"')
175	-
176	- return self.current_question # question or None
177	-
178	- # ========================================================================
179	- # pure functions of the state (no side effects)
180	- # ========================================================================
181	-
182	- def topic_has_finished(self):
183	- return self.current_question is None
184	-
185	- # ------------------------------------------------------------------------
186	- # compute recommended sequence of topics ['a', 'b', ...]
187	- # ------------------------------------------------------------------------
188	- def recommend_topic_sequence(self, target=None):
189	- tt = list(nx.topological_sort(self.deps))
190	- unlocked = [t for t in tt if t in self.state]
191	- locked = [t for t in tt if t not in unlocked]
192	- return unlocked + locked
193	-
194	- # ------------------------------------------------------------------------
195	- def get_current_question(self):
196	- return self.current_question
197	-
198	- # ------------------------------------------------------------------------
199	- def get_current_topic(self):
200	- return self.current_topic
201	-
202	- # ------------------------------------------------------------------------
203	- def is_locked(self, topic):
204	- return topic not in self.state
205	-
206	- # ------------------------------------------------------------------------
207	- # Return list of {ref: 'xpto', name: 'long name', leve: 0.5}
208	- # Levels are in the interval [0, 1] if unlocked or None if locked.
209	- # Topics unlocked but not yet done have level 0.0.
210	- # ------------------------------------------------------------------------
211	- def get_knowledge_state(self):
212	- return [{
213	- 'ref': ref,
214	- 'type': self.deps.nodes[ref]['type'],
215	- 'name': self.deps.nodes[ref]['name'],
216	- 'level': self.state[ref]['level'] if ref in self.state else None
217	- } for ref in self.topic_sequence]
218	-
219	- # ------------------------------------------------------------------------
220	- def get_topic_progress(self):
221	- return self.correct_answers / (1 + self.correct_answers +
222	- len(self.questions))
223	-
224	- # ------------------------------------------------------------------------
225	- def get_topic_level(self, topic):
226	- return self.state[topic]['level']
227	-
228	- # ------------------------------------------------------------------------
229	- def get_topic_date(self, topic):
230	- return self.state[topic]['date']
231	-
232	- # ------------------------------------------------------------------------
233	- # Recommends a topic to practice/learn from the state.
234	- # ------------------------------------------------------------------------
235	- # def get_recommended_topic(self): # FIXME untested
236	- # return min(self.state.items(), key=lambda x: x[1]['level'])[0]
@@ -0,0 +1,236 @@		@@ -0,0 +1,236 @@
	1	+
	2	+# python standard library
	3	+import random
	4	+from datetime import datetime
	5	+import logging
	6	+
	7	+# third party libraries
	8	+import networkx as nx
	9	+
	10	+# setup logger for this module
	11	+logger = logging.getLogger(__name__)
	12	+
	13	+
	14	+# ----------------------------------------------------------------------------
	15	+# kowledge state of each student....??
	16	+# Contains:
	17	+# state - dict of topics with state of unlocked topics
	18	+# deps - access to dependency graph shared between students
	19	+# topic_sequence - list with the order of recommended topics
	20	+# ----------------------------------------------------------------------------
	21	+class StudentState(object):
	22	+ # =======================================================================
	23	+ # methods that update state
	24	+ # =======================================================================
	25	+ def __init__(self, deps, factory, state={}):
	26	+ self.deps = deps # shared dependency graph
	27	+ self.factory = factory # question factory
	28	+ self.state = state # {'topic': {'level': 0.5, 'date': datetime}, ...}
	29	+
	30	+ self.update_topic_levels() # applies forgetting factor
	31	+ self.unlock_topics() # whose dependencies have been completed
	32	+ self.topic_sequence = self.recommend_topic_sequence() # ['ref1', ...]
	33	+ self.current_topic = None
	34	+
	35	+ # ------------------------------------------------------------------------
	36	+ # Updates the proficiency levels of the topics, with forgetting factor
	37	+ # FIXME no dependencies are considered yet...
	38	+ # ------------------------------------------------------------------------
	39	+ def update_topic_levels(self):
	40	+ now = datetime.now()
	41	+ for tref, s in self.state.items():
	42	+ dt = now - s['date']
	43	+ s['level'] = 0.98 * dt.days # forgetting factor
	44	+
	45	+ # ------------------------------------------------------------------------
	46	+ # Unlock topics whose dependencies are satisfied (> min_level)
	47	+ # ------------------------------------------------------------------------
	48	+ def unlock_topics(self):
	49	+ for topic in self.deps.nodes():
	50	+ if topic not in self.state: # if locked
	51	+ pred = self.deps.predecessors(topic)
	52	+ min_level = self.deps.node[topic]['min_level']
	53	+ if all(d in self.state and self.state[d]['level'] > min_level
	54	+ for d in pred): # all deps are greater than min_level
	55	+
	56	+ self.state[topic] = {
	57	+ 'level': 0.0, # unlocked
	58	+ 'date': datetime.now()
	59	+ }
	60	+ logger.debug(f'[unlock_topics] Unlocked "{topic}".')
	61	+ # else: # lock this topic if deps do not satisfy min_level
	62	+ # del self.state[topic]
	63	+
	64	+ # ------------------------------------------------------------------------
	65	+ # Start a new topic.
	66	+ # questions: list of generated questions to do in the topic
	67	+ # current_question: the current question to be presented
	68	+ # ------------------------------------------------------------------------
	69	+ async def start_topic(self, topic):
	70	+ logger.debug(f'[start_topic] topic "{topic}"')
	71	+
	72	+ if self.current_topic == topic:
	73	+ logger.info('Restarting current topic is not allowed.')
	74	+ return
	75	+
	76	+ # do not allow locked topics
	77	+ if self.is_locked(topic):
	78	+ logger.debug(f'[start_topic] topic "{topic}" is locked')
	79	+ return
	80	+
	81	+ # starting new topic
	82	+ self.current_topic = topic
	83	+ self.correct_answers = 0
	84	+ self.wrong_answers = 0
	85	+
	86	+ t = self.deps.node[topic]
	87	+ k = t['choose']
	88	+ if t['shuffle_questions']:
	89	+ questions = random.sample(t['questions'], k=k)
	90	+ else:
	91	+ questions = t['questions'][:k]
	92	+ logger.debug(f'[start_topic] questions: {", ".join(questions)}')
	93	+
	94	+ # synchronous
	95	+ # self.questions = [self.factory[ref].generate()
	96	+ # for ref in questions]
	97	+
	98	+ # asynchronous:
	99	+ self.questions = [await self.factory[ref].generate_async()
	100	+ for ref in questions]
	101	+
	102	+ n = len(self.questions)
	103	+ logger.debug(f'[start_topic] generated {n} questions')
	104	+
	105	+ # get first question
	106	+ self.next_question()
	107	+
	108	+ # ------------------------------------------------------------------------
	109	+ # The topic has finished and there are no more questions.
	110	+ # The topic level is updated in state and unlocks are performed.
	111	+ # The current topic is unchanged.
	112	+ # ------------------------------------------------------------------------
	113	+ def finish_topic(self):
	114	+ logger.debug(f'[finish_topic] current_topic {self.current_topic}')
	115	+
	116	+ self.state[self.current_topic] = {
	117	+ 'date': datetime.now(),
	118	+ 'level': self.correct_answers / (self.correct_answers +
	119	+ self.wrong_answers)
	120	+ }
	121	+ # self.current_topic = None
	122	+ self.unlock_topics()
	123	+
	124	+ # ------------------------------------------------------------------------
	125	+ # corrects current question with provided answer.
	126	+ # implements the logic:
	127	+ # - if answer ok, goes to next question
	128	+ # - if wrong, counts number of tries. If exceeded, moves on.
	129	+ # ------------------------------------------------------------------------
	130	+ async def check_answer(self, answer):
	131	+ logger.debug('[check_answer]')
	132	+
	133	+ q = self.current_question
	134	+ q['answer'] = answer
	135	+ q['finish_time'] = datetime.now()
	136	+ await q.correct_async()
	137	+ logger.debug(f'[check_answer] Grade {q["grade"]:.2} in {q["ref"]}')
	138	+
	139	+ if q['grade'] > 0.999:
	140	+ self.correct_answers += 1
	141	+ self.next_question()
	142	+ action = 'right'
	143	+
	144	+ else:
	145	+ self.wrong_answers += 1
	146	+ self.current_question['tries'] -= 1
	147	+
	148	+ if self.current_question['tries'] > 0:
	149	+ action = 'try_again'
	150	+ else:
	151	+ action = 'wrong'
	152	+ if self.current_question['append_wrong']:
	153	+ logger.debug('[check_answer] Wrong, append new instance')
	154	+ self.questions.append(self.factory[q['ref']].generate())
	155	+ self.next_question()
	156	+
	157	+ # returns corrected question (not new one) which might include comments
	158	+ return q, action
	159	+
	160	+ # ------------------------------------------------------------------------
	161	+ # Move to next question
	162	+ # ------------------------------------------------------------------------
	163	+ def next_question(self):
	164	+ try:
	165	+ self.current_question = self.questions.pop(0)
	166	+ except IndexError:
	167	+ self.current_question = None
	168	+ self.finish_topic()
	169	+ else:
	170	+ self.current_question['start_time'] = datetime.now()
	171	+ default_maxtries = self.deps.nodes[self.current_topic]['max_tries']
	172	+ maxtries = self.current_question.get('max_tries', default_maxtries)
	173	+ self.current_question['tries'] = maxtries
	174	+ logger.debug(f'[next_question] "{self.current_question["ref"]}"')
	175	+
	176	+ return self.current_question # question or None
	177	+
	178	+ # ========================================================================
	179	+ # pure functions of the state (no side effects)
	180	+ # ========================================================================
	181	+
	182	+ def topic_has_finished(self):
	183	+ return self.current_question is None
	184	+
	185	+ # ------------------------------------------------------------------------
	186	+ # compute recommended sequence of topics ['a', 'b', ...]
	187	+ # ------------------------------------------------------------------------
	188	+ def recommend_topic_sequence(self, target=None):
	189	+ tt = list(nx.topological_sort(self.deps))
	190	+ unlocked = [t for t in tt if t in self.state]
	191	+ locked = [t for t in tt if t not in unlocked]
	192	+ return unlocked + locked
	193	+
	194	+ # ------------------------------------------------------------------------
	195	+ def get_current_question(self):
	196	+ return self.current_question
	197	+
	198	+ # ------------------------------------------------------------------------
	199	+ def get_current_topic(self):
	200	+ return self.current_topic
	201	+
	202	+ # ------------------------------------------------------------------------
	203	+ def is_locked(self, topic):
	204	+ return topic not in self.state
	205	+
	206	+ # ------------------------------------------------------------------------
	207	+ # Return list of {ref: 'xpto', name: 'long name', leve: 0.5}
	208	+ # Levels are in the interval [0, 1] if unlocked or None if locked.
	209	+ # Topics unlocked but not yet done have level 0.0.
	210	+ # ------------------------------------------------------------------------
	211	+ def get_knowledge_state(self):
	212	+ return [{
	213	+ 'ref': ref,
	214	+ 'type': self.deps.nodes[ref]['type'],
	215	+ 'name': self.deps.nodes[ref]['name'],
	216	+ 'level': self.state[ref]['level'] if ref in self.state else None
	217	+ } for ref in self.topic_sequence]
	218	+
	219	+ # ------------------------------------------------------------------------
	220	+ def get_topic_progress(self):
	221	+ return self.correct_answers / (1 + self.correct_answers +
	222	+ len(self.questions))
	223	+
	224	+ # ------------------------------------------------------------------------
	225	+ def get_topic_level(self, topic):
	226	+ return self.state[topic]['level']
	227	+
	228	+ # ------------------------------------------------------------------------
	229	+ def get_topic_date(self, topic):
	230	+ return self.state[topic]['date']
	231	+
	232	+ # ------------------------------------------------------------------------
	233	+ # Recommends a topic to practice/learn from the state.
	234	+ # ------------------------------------------------------------------------
	235	+ # def get_recommended_topic(self): # FIXME untested
	236	+ # return min(self.state.items(), key=lambda x: x[1]['level'])[0]