tko 2.2.3__tar.gz → 2.3.1__tar.gz

{tko-2.2.3/src/tko.egg-info → tko-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tko
-Version: 2.2.3
+Version: 2.3.1
 Summary: tko: Test Kit Operations
 Home-page: https://github.com/senapk/tko
 Author: David Sena Oliveira

{tko-2.2.3 → tko-2.3.1}/changelog.md

@@ -1,5 +1,9 @@
 # Changelog
 
+- 2.3.1
+  - fix: error in search
+- 2.3.0
+  - add: new evaluate menu
 - 2.2.3
   - fix: change diff mode
 - 2.2.2

tko-2.3.1/src/tko/__init__.py

@@ -0,0 +1 @@
+__version__ = "2.3.1"

{tko-2.2.3 → tko-2.3.1}/src/tko/cmds/cmd_play.py

@@ -31,11 +31,11 @@ class CmdPlay:
         
         logger: Logger = Logger.get_instance()
         logger.set_history_file(self.rep.get_history_file())
-        logger.record_other_event(LogAction.OPEN)
+        logger.record_open()
         play = Play(self.settings, self.rep)
         logger.set_daily(self.rep.get_daily_file(), play.game.tasks)
         play.play()
-        logger.record_other_event(LogAction.QUIT)
+        logger.record_quit()
 
 
     # @staticmethod

{tko-2.2.3 → tko-2.3.1}/src/tko/game/game.py

@@ -68,26 +68,26 @@ class Game:
                     if s in total:
                         total[s] += t.skills[s]
                         if reachable:
-                            obtained[s] += int(t.skills[s] * t.self_grade/10)
+                            obtained[s] += int(t.skills[s] * t.get_ratio())
                         else:
                             obtained[s] += 0
                     else:
                         total[s] = t.skills[s]
                         if reachable:
-                            obtained[s] = int(t.skills[s] * t.self_grade/10)
+                            obtained[s] = int(t.skills[s] * t.get_ratio())
                         else:
                             obtained[s] = 0
                 for s in t.qskills:
                     if s in total:
                         total[s] += t.qskills[s]
                         if reachable:
-                            obtained[s] += int(t.qskills[s] * t.self_grade/10)
+                            obtained[s] += int(t.qskills[s] * t.get_ratio())
                         else:
                             obtained[s] += 0
                     else:
                         total[s] = t.qskills[s]
                         if reachable:
-                            obtained[s] = int(t.qskills[s] * t.self_grade/10)
+                            obtained[s] = int(t.qskills[s] * t.get_ratio())
                         else:
                             obtained[s] = 0
         return total, obtained

{tko-2.2.3 → tko-2.3.1}/src/tko/game/quest.py

@@ -42,7 +42,7 @@ class Quest(TreeItem):
             if i == 0:
                 self.__tasks[i].set_reachable(True)
             else:
-                if self.__tasks[i-1].get_total_percent() < 50:
+                if self.__tasks[i-1].get_percent() < 50:
                     reach = False
                 self.__tasks[i].set_reachable(reach)
 
@@ -65,10 +65,10 @@ class Quest(TreeItem):
         return Text()
 
     def get_resume_by_tasks(self) -> Text:
-        tmin = self.tmin if self.tmin is not None else 7
+        tmin = self.tmin if self.tmin is not None else 70
         total = len([t for t in self.__tasks if not t.opt])
         plus = len([t for t in self.__tasks if t.opt])
-        count = len([t for t in self.__tasks if t.self_grade >= tmin])
+        count = len([t for t in self.__tasks if t.get_percent() >= tmin])
         output = f"{count}/{total}"
         if plus > 0:
             output += f"+{plus}"
@@ -89,7 +89,7 @@ class Quest(TreeItem):
         # task complete mode
         if self.tmin is not None:
             for t in self.__tasks:
-                if not t.opt and t.self_grade < self.tmin:
+                if not t.opt and t.get_percent() < self.tmin:
                     return False
         return True
 
@@ -118,8 +118,8 @@ class Quest(TreeItem):
         obtained = 0
         for t in self.__tasks:
             total += t.xp
-            if t.self_grade > 0:
-                obtained += t.xp * t.self_grade // 10
+            if t.get_percent() > 0:
+                obtained += int(t.xp * t.get_ratio())
 
         return obtained, total
         
@@ -127,13 +127,13 @@ class Quest(TreeItem):
         obtained, total = self.get_xp()
         if total == 0:
             return 0
-        return obtained * 100 // total
+        return obtained * 10 // total
 
     def in_progress(self):
         if self.is_complete():
             return False
         for t in self.__tasks:
-            if t.self_grade != 0:
+            if t.get_percent() != 0:
                 return True
         return False
 

{tko-2.2.3 → tko-2.3.1}/src/tko/game/task.py

@@ -20,9 +20,10 @@ class Task(TreeItem):
         self.line_number = 0
         self.line = ""
 
-        self.self_grade: int = 0 #valor de 0 a 9
-        self.progress: int = 0 #valor de 0 a 100
-        self.main_index: int = 0
+        self.coverage: int = 0 # valor de 0 a 100
+        self.autonomy: int = 0 # valor de 0 a 5
+        self.ability: int = 0 # valor de 0 a 5
+        self.main_idx: int = 0
 
         self.qskills: Dict[str, int] = {} # default quest skills
         self.skills: Dict[str, int] = {} # local skills
@@ -64,26 +65,37 @@ class Task(TreeItem):
     def get_track_folder(self) -> str | None:
         return self.track_folder
 
+    def set_autonomy_ability(self, value: int):
+        opts = [(0, 0), (1, 1), (1, 2), (2, 2), (3, 2), (1, 3), (2, 3), (3, 3), (4, 3), (3, 4), (4, 4)]
+        self.autonomy = opts[value][0]
+        self.ability = opts[value][1]
+
+
     def load_from_db(self, value: str):
         if ":" not in value:
-            self.self_grade = int(value)
+            self.set_autonomy_ability(int(value))
         else:
             v = value.split(":")
             if len(v) == 3:
-                self.self_grade = int(v[0])
-                self.main_index = int(v[1])
-                self.progress = int(v[2])
+                self.set_autonomy_ability(int(v[0]))
+                self.main_idx = int(v[1])
+                self.coverage = int(v[2])
+            elif len(v) == 4:
+                self.coverage = (int(v[0]))
+                self.autonomy = (int(v[1]))
+                self.ability = (int(v[2]))
+                self.main_idx = (int(v[3]))
 
     def save_to_db(self) -> str:
-        return f"{self.self_grade}:{self.main_index}:{self.progress}"
+        return f"{self.coverage}:{self.autonomy}:{self.ability}:{self.main_idx}"
     
     def is_db_empty(self) -> bool:
-        return self.self_grade == 0 and self.main_index == 0 and self.progress == 0
+        return self.autonomy == 0 and self.ability == 0 and self.main_idx == 0 and self.coverage == 0
 
     def get_prog_color(self, min_value: Optional[int] = None) -> str:
         if min_value is None:
             min_value = self.default_min_value
-        prog = self.progress // 10
+        prog = self.coverage // 10
         if prog == 0:
             return "c"
         if prog < min_value:
@@ -99,9 +111,9 @@ class Task(TreeItem):
         if min_value is None:
             min_value = self.default_min_value
         color = self.get_prog_color(min_value)
-        prog = self.progress // 10
+        prog = self.coverage // 10
         if prog == 0:
-            return Text().addf(color, "0")
+            return Text().add("x")
         if prog < min_value:
             return Text().addf(color, str(prog))
         if prog < 10:
@@ -111,38 +123,40 @@ class Task(TreeItem):
         return Text().add("0")
 
     def get_percent(self):
-        if self.self_grade == 0:
-            return 0
-        if self.self_grade == 10:
-            return 100
-        return self.self_grade * 10
+        return (self.autonomy / 5) * (self.ability / 5) * self.coverage
     
-    def get_total_percent(self):
-        # return (self.self_grade * 10 + self.progress) // 2
-        return self.self_grade * self.progress // 10
+    def get_ratio(self) -> float:
+        return self.get_percent() / 10.0
 
     def is_complete(self):
-        return self.self_grade == 10
+        return self.get_percent() == 100
 
     def not_started(self):
-        return self.self_grade == 0
+        return self.get_percent() == 0
     
     def in_progress(self):
-        return self.self_grade > 0 and self.self_grade < 10
+        return self.get_percent() > 0 and self.get_percent() < 100
+
+    def set_coverage(self, coverage: int):
+        coverage = int(coverage)
+        if coverage >= 0 and coverage <= 100:
+            self.coverage = coverage
+        else:
+            print(f"Progresso inválido: {coverage}")
 
-    def set_progress(self, progress: int):
-        progress = int(progress)
-        if progress >= 0 and progress <= 100:
-            self.progress = progress
+    def set_autonomy(self, value: int):
+        value = int(value)
+        if value >= 0 and value <= 5:
+            self.autonomy = value
         else:
-            print(f"Progresso inválido: {progress}")
+            print(f"Autonomia inválida: {value}")
 
-    def set_grade(self, grade: int):
-        grade = int(grade)
-        if grade >= 0 and grade <= 10:
-            self.self_grade = grade
+    def set_hability(self, value: int):
+        value = int(value)
+        if value >= 0 and value <= 5:
+            self.ability = value
         else:
-            print(f"Grade inválida: {grade}")
+            print(f"Compreensão inválida: {value}")
 
     def get_download_link(self) -> str:
         return self.download_link
@@ -153,7 +167,7 @@ class Task(TreeItem):
     def __str__(self):
         lnum = str(self.line_number).rjust(3)
         key = "" if self.key == self.title else self.key + " "
-        return f"{lnum} grade:{self.self_grade} key:{key} title:{self.title} skills:{self.skills} down:{self.download_link} vis:{self.visitable_url}"
+        return f"{lnum} grade:{self.autonomy}:{self.ability} key:{key} title:{self.title} skills:{self.skills} down:{self.download_link} vis:{self.visitable_url}"
 
     def has_at_symbol(self):
         return any([s.startswith("@") for s in self.title.split(" ")])

{tko-2.2.3 → tko-2.3.1}/src/tko/play/floating.py

@@ -6,6 +6,7 @@ import curses
 from typing import Callable
 from tko.play.input_manager import InputManager
 from tko.util.symbols import symbols
+from tko.game.task import Task
 
 class Floating:
     def __init__(self, _align=""):
@@ -38,7 +39,7 @@ class Floating:
         self._frame.set_header(Text().addf("/", text), "")
         return self
     
-    def set_header_sentence(self, sentence: Text):
+    def set_header_text(self, sentence: Text):
         self._frame.set_header(sentence, "")
         return self
     
@@ -46,6 +47,10 @@ class Floating:
         self._frame.set_footer(Text().addf("/", text), "")
         return self
     
+    def set_footer_text(self, sentence: Text):
+        self._frame.set_footer(sentence, "")
+        return self
+    
     def set_exit_key(self, key: str):
         self._exit_key = ord(key)
         return self
@@ -167,6 +172,107 @@ class Floating:
         
         return -1
         
+class FloatingGrade(Floating):
+    def __init__(self, task: Task, _align=""):
+        super().__init__(_align)
+        self._task = task
+        self._line = 0
+        self.set_text_ljust()
+        self._frame.set_border_color("g")
+        self.set_header_text(Text.format("{y/}", " Utilize os direcionais para  marcar "))
+        self.set_footer_text(Text.format("{y/}", " Pressione Enter para confirmar "))
+
+        self.grades_index = [task.coverage // 10, task.autonomy, task.ability]
+        self.coverage = ["x", "1", "2", "3", "4", "5", "6", "7", "8", "9", "✓"]
+        self.coverage_msg = [
+            "Não fiz", 
+            "Fiz 10%", 
+            "Fiz 20%", 
+            "Fiz 30%", 
+            "Fiz 40%",
+            "Fiz 50%",
+            "Fiz 60%",
+            "Fiz 70%",
+            "Fiz 80%",
+            "Fiz 90%",
+            "Fiz 100%"]
+        self.autonomy = [x.text for x in [symbols.autonomy_x, symbols.autonomy_e, symbols.autonomy_d, symbols.autonomy_c, symbols.autonomy_b, symbols.autonomy_a]]
+        self.autonomy_msg = [
+            "Não fiz             ", 
+            "Copiei              ", 
+            "Fiz guiado          ", 
+            "Fiz com muita ajuda ", 
+            "Fiz com ajuda       ", 
+            "Fiz sem ajuda       "
+            ]
+        self.hability = [x.text for x in [symbols.hability_x, symbols.hability_e, symbols.hability_d, symbols.hability_c, symbols.hability_b, symbols.hability_a]]
+        self.hability_msg = [
+            "Não fiz            ", 
+            "Não entendi        ", 
+            "Entendi uma parte  ", 
+            "Entendi boa parte  ", 
+            "Entendi quase tudo ", 
+            "Entendi tudo       "
+            ]
+        self.grades_value = [self.coverage, self.autonomy, self.hability]
+        self.grades_msg = [self.coverage_msg, self.autonomy_msg, self.hability_msg]
+
+    
+    def update_content(self):
+        self._content = []
+        self._content.append(Text())
+        coverage_text = Text().add("   ").addf("Y" if self._line == 0 else "", "Cobertura").add("  ")
+        for i, c in enumerate(self.coverage):
+            coverage_text.addf("C" if i == self.grades_index[0] else "", c)
+        coverage_text.add("  ").addf("m", self.coverage_msg[self.grades_index[0]])
+        self._content.append(coverage_text)
+        # self._content.append(Text())
+        hability_text = Text().add("   ").addf("Y" if self._line == 1 else "", "Autonomia").add("  ")
+        for i, c in enumerate(self.autonomy):
+            hability_text.addf("G" if i == self.grades_index[1] else "", c).add(" ")
+        hability_text.add(" ").addf("m", self.autonomy_msg[self.grades_index[1]])
+        self._content.append(hability_text)
+        # self._content.append(Text())
+        autonomy_text = Text().add(" ").addf("Y" if self._line == 2 else "", "Compreensão").add("  ")
+        for i, c in enumerate(self.hability):
+            autonomy_text.addf("yW" if i == self.grades_index[2] else "", c).add(" ")
+        autonomy_text.add(" ").addf("m", self.hability_msg[self.grades_index[2]])
+        self._content.append(autonomy_text)
+        self._content.append(Text())
+        
+    def draw(self):
+        self._set_default_header()
+        self._set_default_footer()
+        self.setup_frame()
+        self._frame.draw()
+        self.update_content()
+        self.write_content()
+
+    def change_task(self):
+        self._task.set_coverage(self.grades_index[0] * 10)
+        self._task.set_autonomy(self.grades_index[1])
+        self._task.set_hability(self.grades_index[2])
+
+    def get_input(self) -> int:
+        self.draw()
+        key: int = Fmt.getch()
+        key = InputManager.fix_cedilha(Fmt.get_screen(), key)
+        if key == curses.KEY_UP or key == ord('w'):
+            self._line = max(self._line - 1, 0)
+        elif key == curses.KEY_DOWN or key == ord('s'):
+            self._line = min(self._line + 1, 2)
+        elif key == curses.KEY_LEFT or key == ord('a'):
+            self.grades_index[self._line] = max(self.grades_index[self._line] - 1, 0)
+            self.change_task()
+        elif key == curses.KEY_RIGHT or key == ord('d'):
+            self.grades_index[self._line] = min(self.grades_index[self._line] + 1, len(self.grades_value[self._line]) - 1)
+            self.change_task()
+        elif key == ord('\n') or key == curses.KEY_BACKSPACE or key == InputManager.esc:
+            self._enable = False
+            if self._exit_fn is not None:
+                self._exit_fn()        
+        return -1
+
 class FloatingInputData:
     def __init__(self, label: Callable[[], Text], action: Callable[[], None], shortcut: str = ""):
         self.label = label

{tko-2.2.3 → tko-2.3.1}/src/tko/play/grade_message.py

@@ -16,33 +16,51 @@ Sem   Ajuda│$5  Sozinho  │           │           │    [8]    │    [10]
 """[1:-1]
         
         self.emoji: Dict[str, Token] = {
-            "$1": symbols.compreensao_d,
-            "$2": symbols.compreensao_c,
-            "$3": symbols.compreensao_b,
-            "$4": symbols.compreensao_a,
-            "$5": symbols.suporte_a,
-            "$6": symbols.suporte_b,
-            "$7": symbols.suporte_c,
-            "$8": symbols.suporte_d
+            "$1": symbols.hability_d,
+            "$2": symbols.hability_c,
+            "$3": symbols.hability_b,
+            "$4": symbols.hability_a,
+            "$5": symbols.autonomy_a,
+            "$6": symbols.autonomy_b,
+            "$7": symbols.autonomy_c,
+            "$8": symbols.autonomy_d
         }
 
         self.axes: Dict[int, list[str]] = {}
         self.load_axes()
 
+    @staticmethod
+    def autonomy_emoji(value):
+         return [symbols.autonomy_x,
+                 symbols.autonomy_e, 
+                 symbols.autonomy_d,
+                 symbols.autonomy_c,
+                 symbols.autonomy_b,
+                 symbols.autonomy_a][value]
+
+    @staticmethod
+    def hability_emoji(value):
+         return [symbols.hability_x,
+                 symbols.hability_e, 
+                 symbols.hability_d,
+                 symbols.hability_c,
+                 symbols.hability_b,
+                 symbols.hability_a][value]
+
     @staticmethod
     def grade_to_emojis(grade: int) -> Text:
         decode_dict = {
-                0: (symbols.suporte_e, symbols.compreensao_e),
-                1: (symbols.suporte_d, symbols.compreensao_d),
-                2: (symbols.suporte_d, symbols.compreensao_c),
-                3: (symbols.suporte_c, symbols.compreensao_c),
-                4: (symbols.suporte_b, symbols.compreensao_c),
-                5: (symbols.suporte_d, symbols.compreensao_b),
-                6: (symbols.suporte_c, symbols.compreensao_b),
-                7: (symbols.suporte_b, symbols.compreensao_b),
-                8: (symbols.suporte_a, symbols.compreensao_b),
-                9: (symbols.suporte_b, symbols.compreensao_a),
-                10: (symbols.suporte_a, symbols.compreensao_a)
+                0: (symbols.autonomy_e, symbols.hability_e),
+                1: (symbols.autonomy_d, symbols.hability_d),
+                2: (symbols.autonomy_d, symbols.hability_c),
+                3: (symbols.autonomy_c, symbols.hability_c),
+                4: (symbols.autonomy_b, symbols.hability_c),
+                5: (symbols.autonomy_d, symbols.hability_b),
+                6: (symbols.autonomy_c, symbols.hability_b),
+                7: (symbols.autonomy_b, symbols.hability_b),
+                8: (symbols.autonomy_a, symbols.hability_b),
+                9: (symbols.autonomy_b, symbols.hability_a),
+                10: (symbols.autonomy_a, symbols.hability_a)
         }
         a = decode_dict[grade][0]
         b = decode_dict[grade][1]
@@ -107,8 +125,8 @@ Sem   Ajuda│$5  Sozinho  │           │           │    [8]    │    [10]
                         # pos += 1
             
             pos = value.get_text().find("Não Fiz")
-            value.data[pos - 3] = symbols.suporte_e
-            value.data[pos - 2] = symbols.compreensao_e
+            value.data[pos - 3] = symbols.autonomy_e
+            value.data[pos - 2] = symbols.hability_e
             # marcando axes com a cor correspondente
             if grade > 0 and grade <= 10:
                 value = value.replace(self.axes[grade][0], Token(self.axes[grade][0], "M"))

{tko-2.2.3 → tko-2.3.1}/src/tko/play/gui.py

@@ -42,11 +42,19 @@ class Gui:
 
 
     def get_help_fixed(self):
+        color = "W"
+        try:
+            selected = self.tree.get_selected_throw()
+            if isinstance(selected, Task):
+                color = "Y"
+        except IndexError:
+            pass
+
         help_fixed: List[Text] = [
-            Text() + RToken("C", f" {GuiActions.leave}  [{GuiKeys.key_quit}]"),
-            Text() + RToken("Y", f"{GuiActions.palette} [{GuiKeys.palette}]"),
+            Text() + RToken("C", f"{GuiActions.palette} [{GuiKeys.palette}]"),
+            Text() + RToken(color, f"{GuiActions.evaluate}[.]"),
             Text() + RToken("G", f"{self.get_activate_label()} [↲]"),
-            Text() + RToken("Y", f"{GuiActions.edit} [{GuiKeys.edit}]"),
+            Text() + RToken(color, f"{GuiActions.edit} [{GuiKeys.edit}]"),
             # Text() + RToken("C", f"{GuiActions.navegar} [wasd]")
             Text() + RToken("C", f"{GuiActions.search} [{GuiKeys.search}]")
         ]
@@ -55,7 +63,7 @@ class Gui:
     def get_activate_label(self) -> str:
         output: str = GuiActions.activate
         try:
-            obj = self.tree.get_selected()
+            obj = self.tree.get_selected_throw()
         except IndexError:
             return " Retornar"
         if isinstance(obj, Quest):
@@ -198,19 +206,18 @@ class Gui:
 
     def show_top_bar(self, frame: Frame):
         lista = [
-            Text() + RToken("Y", f"{GuiActions.self_grade} {GuiKeys.dec_self1}{GuiKeys.inc_self1}"),
-            Text() + RToken("Y", f"{GuiActions.progress} {GuiKeys.dec_prog1}{GuiKeys.inc_prog1}"),
+            Text() + RToken("Y", f"Sair  [q]"),
+            Text() + RToken("Y", f"Ajuda [?]"),
         ]
         help = self.build_list_sentence(lista)
-        self_grade = help[0]
-        progress = help[1]
-        # pesquisar = help[2]
+        search = help[0]
+        evaluate = help[1]
 
         pre: List[Text] = []
-        pre.append(progress)
+        pre.append(search)
 
         pos: List[Text] = []
-        pos.append(self_grade)
+        pos.append(evaluate)
 
         limit = frame.get_dx()
         size = limit - Text().add(" ").join(pre + pos).len() - 2
@@ -224,7 +231,7 @@ class Gui:
         _help: Floating = Floating("v>").set_text_ljust()
         self.fman.add_input(_help)
 
-        _help.set_header_sentence(Text().add(" Ajuda "))
+        _help.set_header_text(Text().add(" Ajuda "))
         # _help.put_text(" Movimentação ".center(dx, symbols.hbar.text))
         _help.put_sentence(Text.format("    Ajuda ").addf("r", GuiKeys.key_help).add("  Abre essa tela de ajuda")
         )
@@ -232,11 +239,15 @@ class Gui:
         _help.put_sentence(Text.format("  ").addf("r", "Shift + B")
                            .add("  Habilita ").addf("r", "").addf("R", "ícones").addf("r", "").add(" se seu ambiente suportar"))
         _help.put_sentence(Text() + "" + RToken("g", "setas") + ", " + RToken("g", "wasd")  + "  Para navegar entre os elementos")
+        _help.put_sentence(Text() + f"   {GuiActions.palette} " + RToken("r", f"{GuiKeys.palette}") + "  Abre o menu de ações e configurações")
         _help.put_sentence(Text() + f"   {GuiActions.github} " + RToken("r", f"{GuiKeys.github_open}") + "  Abre tarefa em uma aba do browser")
         _help.put_sentence(Text() + f"   {GuiActions.download} " + RToken("r", f"{GuiKeys.down_task}") + "  Baixa tarefa de código para seu dispositivo")
         _help.put_sentence(Text() + f"   {GuiActions.edit} " + RToken("r", f"{GuiKeys.edit}") + "  Abre os arquivos no editor de código")
-        _help.put_sentence(Text() + f"   {GuiActions.activate} " + RToken("r", "↲") + "  Interage com o elemento")
-        _help.put_sentence(Text() + f"    {GuiActions.self_grade}" + RToken("r", f"{GuiKeys.dec_self1}") + RToken("r", f"{GuiKeys.inc_self1}") + " Muda a autoavaliação")
+        _help.put_sentence(Text() + f"   {GuiActions.activate} " + RToken("r", "↲") + "  Interage com o elemento de acordo com o contexto")
+        _help.put_sentence(Text() + "             (baixar, visitar, escolher, compactar, expandir)")
+        _help.put_sentence(Text() + f"  {GuiActions.evaluate} " + RToken("r", ".") + "  Abre tela para auto avaliação")
+        _help.put_sentence(Text() + f"{GuiActions.search} " + RToken("r", f"{GuiKeys.search}") + "  Abre a barra de pesquisa")
+
         _help.put_sentence(Text())
         _help.put_sentence(Text() + "Você pode mudar o editor padrão com o comando")
         _help.put_sentence(Text() + RToken("g", "             tko config --editor <comando>"))
@@ -263,10 +274,8 @@ class Gui:
         return text, percent
 
     def show_opening(self, frame: Frame):
-        # if Fmt.get_size()[1] < 100:
-        #     return
-        # if not self.app.has_images():
-        #     return
+        if not self.app.has_images():
+            return
         _, cols = Fmt.get_size()
         
         now = datetime.datetime.now()

{tko-2.2.3 → tko-2.3.1}/src/tko/play/images.py

@@ -32,16 +32,15 @@ opening: Dict[str, str] = {}
 # """
 
 opening["estuda"] = r"""
-O modelo de avaliação usa 3 notas.
-Progresso, Autonomia e Compreensão
-Progresso é o QUANTO você fez.
-Ele é gerado automaticamente pelos
-testes ou manualmente usando +-.
-Autonomia e Compreensão são COMO.
-Use <> para marcar COMO você fez.
-Progressao : ✓ 9.... 0
-Compreensão: A B C D E
-Autonomia  : █ ▅ ▃ ▂ ▁
+O modelo de avaliação usa 3 notas 
+  Cobertura: quanto da atividade você fez
+  Autonomia: quanta ajuda você precisou
+             (ChatGpt, Copilot, Monitoria)
+Compreensão: quanto você entendeu do que fez
+
+Cobertura   : 0 1 ... 9 ✓
+Autonomia   : x E D C B A
+Compreensão : x ▁ ▂ ▃ ▅ █    
 
  ,`````.          __||||___       
 ' Estuda`,       /_  ___   \      

{tko-2.2.3 → tko-2.3.1}/src/tko/play/keys.py

@@ -10,11 +10,10 @@ class GuiActions:
     download = "Baixar"
     activate = "Ativar"
     navigate = "←↓→"
-    progress = "Quanto"
     uncheck = "Desmarcar"
     search = "Pesquisar"
-    self_grade = " Como "
     palette = "Paleta"
+    evaluate = "Avaliar"
     all = "Todos"
 
 class GuiKeys:
@@ -28,17 +27,8 @@ class GuiKeys:
     down_task = "b"
     activate = "\n"
     key_help = "?"
-    
-    inc_prog1 = "+"
-    inc_prog2 = "="
-    dec_prog1 = "-"
-    dec_prog2 = "_"
-    
-    inc_self1 = ">"
-    inc_self2 = "."
-    dec_self1 = "<"
-    dec_self2 = ","
-    
+        
+    evaluate = "j"
     set_root_dir = "D"
     set_lang = "L"
     github_open = "g"
@@ -48,6 +38,7 @@ class GuiKeys:
     borders = "B"
     search = "/"
     graph = "G"
+    evaluate = "."
     diff = "m"
     interact = "i"
     test = "\n"