verifica 1.0.0.dev2__tar.gz → 1.0.2__tar.gz

{verifica-1.0.0.dev2/src/verifica.egg-info → verifica-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: verifica
-Version: 1.0.0.dev2
+Version: 1.0.2
 Summary: Uma ferramenta simples para correção de atividades em python via CLI.
 Author-email: Théo Modeneis Ruela <theo.ruela@gmail.com>
 License-Expression: MIT
@@ -8,7 +8,7 @@ Project-URL: Homepage, https://github.com/espinafr/Verifica
 Project-URL: Issues, https://github.com/espinafr/Verifica/issues
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9.13
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: colorama>=0.4.6
@@ -24,9 +24,6 @@ Dynamic: license-file
                 <td><a href="https://pypi.org/project/verifica/">Página no Pypi</a></td>
                 <td align="right"><a href="https://github.com/espinafr/verifica/issues/new?template=denúncia-de-bug.yml">Reportar bug</a></td>
             </tr>
-            <tr>
-                <td colspan="2" align="center"><a href="https://espinafr.github.io/verifica">Gerador <code>correcao.json</code></a></td>
-            </tr>
             <tr>
                 <td colspan="2" align="center"><a href="https://github.com/espinafr/verifica/tree/master/docs">Como configurar</a></td>
             </tr>
@@ -74,7 +71,7 @@ pip install dist/{NOME DO ARQUIVO GERADO}
 
 ## Reconhecimentos
 
-Veja o arquivo [ACKNOWLEDGEMENTS](https://github.com/espinafr/verifica/blob/master/ACKNOWLEDGEMENTS.md)
+Veja o arquivo [ACKNOWLEDGEMENTS](https://github.com/espinafr/verifica/blob/master/ACKNOWLEDGEMENTS.md).
 
 ## Licença
 

{verifica-1.0.0.dev2 → verifica-1.0.2}/README.md

@@ -7,9 +7,6 @@
                 <td><a href="https://pypi.org/project/verifica/">Página no Pypi</a></td>
                 <td align="right"><a href="https://github.com/espinafr/verifica/issues/new?template=denúncia-de-bug.yml">Reportar bug</a></td>
             </tr>
-            <tr>
-                <td colspan="2" align="center"><a href="https://espinafr.github.io/verifica">Gerador <code>correcao.json</code></a></td>
-            </tr>
             <tr>
                 <td colspan="2" align="center"><a href="https://github.com/espinafr/verifica/tree/master/docs">Como configurar</a></td>
             </tr>
@@ -57,7 +54,7 @@ pip install dist/{NOME DO ARQUIVO GERADO}
 
 ## Reconhecimentos
 
-Veja o arquivo [ACKNOWLEDGEMENTS](https://github.com/espinafr/verifica/blob/master/ACKNOWLEDGEMENTS.md)
+Veja o arquivo [ACKNOWLEDGEMENTS](https://github.com/espinafr/verifica/blob/master/ACKNOWLEDGEMENTS.md).
 
 ## Licença
 

{verifica-1.0.0.dev2 → verifica-1.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "verifica"
-version = "1.0.0.dev2"
+version = "1.0.2"
 dependencies = [
     "colorama>=0.4.6",
     "platformdirs>=2.5.2"
@@ -14,7 +14,7 @@ authors = [
 ]
 description = "Uma ferramenta simples para correção de atividades em python via CLI."
 readme = "README.md"
-requires-python = ">=3.9.13"
+requires-python = ">=3.9"
 classifiers = [
     "Programming Language :: Python :: 3",
     "Operating System :: OS Independent",

{verifica-1.0.0.dev2 → verifica-1.0.2}/src/verifica/__main__.py

@@ -1,17 +1,20 @@
 import argparse
 from pathlib import Path
+from colorama import init
 import logging
 import sys
 
 from .config import settings
 from .check import Checker
 from .fetcher import Fetcher
+from .builder import Builder
 
 logging.basicConfig(
     level=logging.ERROR,
     format='%(levelname)s - %(message)s',
     handlers=[logging.FileHandler(f'{settings.config_dir}/app.log', mode='w', encoding='utf-8'), logging.StreamHandler(stream=sys.stdout)]
 )
+init(autoreset=True)
 
 def main():
     parser = argparse.ArgumentParser(description="Uma ferramenta simples para correção de atividades em python via CLI.", add_help=False)
@@ -24,7 +27,9 @@ def main():
     options.add_argument("-c", "--config", action="store_true", help="Mostra o caminho do arquivo de configuração.")
     options.add_argument("-d", "--debug", action="store_true", help="Ativa o modo debug, mostrando mais informações durante a execução.")
     options.add_argument("-l", "--local", action="store_true", help="Caminho local para a pasta com o arquivo de respostas, caso não queira baixar do github.")
-    
+    options.add_argument("--version", action="store_true", help="Mostra a versão do programa.")
+    options.add_argument("-b", "--builder", action="store_true", help="TUI para criar arquivos de correção de atividades.")  
+
     args = parser.parse_args()
 
     if args.debug:
@@ -35,6 +40,15 @@ def main():
         print(settings.config_path)
         return
 
+    if args.version:
+        print(settings.get_version())
+        return
+
+    if args.builder:
+        builder = Builder()
+        builder.start()
+        return
+
     if not args.atividade:
         parser.error("o seguinte argumento é obrigatório: atividade")
 
@@ -55,7 +69,11 @@ def main():
             logging.error(f"Não foi possível localizar o arquivo de correção em '{args.atividade}'")
             sys.exit(1)
 
-    decoded_answers = answers.get_decoded_json()
+    try:
+        decoded_answers = answers.get_decoded_json()
+    except Exception as _:
+        sys.exit(1)
+
     answers.cleanup()
 
     checker = Checker(args.files, decoded_answers)

verifica-1.0.2/src/verifica/builder.py

@@ -0,0 +1,447 @@
+from colorama import Style, Fore
+from functools import wraps
+from pathlib import Path
+import subprocess
+import copy
+import json
+import sys
+import os
+
+from .tui import TUI, ANSI_PATTERN
+from .config import settings
+
+# Código ANSI para limpar a linha atual no terminal
+CLEAR_LINE = "\r\033[K"
+
+class Controller:
+    @staticmethod
+    def clear_command():
+        if os.name == 'nt':
+            subprocess.run(['cmd', '/c', 'cls'])
+        else:
+            subprocess.run(['clear'])
+
+
+    def clear_terminal(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            Controller.clear_command()
+            return func(*args, **kwargs)
+        return wrapper
+
+
+    def loop_breaker(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            try:
+                return func(*args, **kwargs)
+            except KeyboardInterrupt:
+                return None
+        return wrapper
+
+
+    def sequential_question(input_text):
+        answers = []
+        try:
+            while True:
+                result = input(input_text)
+                answers.append(result)
+
+                # Altera a linha anterior para explicitar que foi salvo
+                sys.stdout.write("\033[F\033[K")
+                sys.stdout.flush()
+                print(f"{Fore.GREEN}{ANSI_PATTERN.sub('', input_text)}{result}{Style.RESET_ALL}")
+        except KeyboardInterrupt:
+            return answers
+
+
+    def required_question(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            while True:
+                result = func(*args, **kwargs)
+                if not isinstance(result, str) or result.strip() == "":
+                    print(f"{Style.BRIGHT}{Fore.RED}Este campo é obrigatório. Por favor, insira um valor válido.{Style.RESET_ALL}")
+                else:
+                    return result
+        return wrapper
+
+
+    def required_text(text) -> str:
+        return f"{Fore.RED}{text}{Style.RESET_ALL}"
+
+
+    def optional_text(text) -> str:
+        return f"{Fore.YELLOW}{text}{Style.RESET_ALL}"
+
+
+    def sequence_text(text) -> str:
+        return f"{Fore.GREEN}{text}{Style.RESET_ALL}"
+
+
+class Selector:
+    def __init__(self, name: str, action, selected: bool = False):
+        self.name = name
+        self.action = action
+        self.selected = selected
+
+class FileBuilder(Controller):
+    def __init__(self, file: str):
+        self.file = file
+        self.selectors = [
+            Selector("Classe", self.create_classes),
+            Selector("Função", self.create_functions),
+            Selector("CLI", self.create_cli),
+            Selector("Inputs", self.create_inputs),
+        ]
+        self.current_file = {}
+
+
+    @Controller.clear_terminal
+    def show_selector(self):
+        if not hasattr(self, 'tui'):
+            self.tui = TUI([self.file, {"":f"Selecione o tipo de funcionalidade que você quer testar no arquivo {Style.BRIGHT}{Fore.CYAN}{self.file}{Style.RESET_ALL}. Digite o número correspondente e aperte ENTER."}, {}], max_line=50)
+
+        for index, selector in enumerate(self.selectors):
+            self.tui.contents[2][f"{Style.BRIGHT}{Fore.CYAN}[{index + 1}]"] = f"{Fore.GREEN if selector.selected else Fore.WHITE}{selector.name}"
+
+        self.tui.show()
+
+
+    def index_is_selectable(self, index: int) -> bool:
+        try:
+            index = int(index)
+            available_selectors = len(self.selectors)
+            if index <= available_selectors and index >= 1:
+                return True
+            else:
+                return False
+        except ValueError:
+            return False
+
+
+    def get_selectors(self):
+        self.show_selector()
+        selecteds = 0
+        while True:
+            index = Controller.required_question(input)(Controller.required_text("> "))
+            if self.index_is_selectable(index):
+                self.selectors[int(index) - 1].selected = True
+                selecteds += 1
+                break
+
+        self.show_selector()
+        while True:
+            index = input(Controller.optional_text("> "))
+            if index.strip() != "":
+                if self.index_is_selectable(index):
+                    index = int(index)
+                    self.selectors[index - 1].selected = not self.selectors[index - 1].selected
+                    if self.selectors[index - 1].selected:
+                        selecteds += 1
+                    else:
+                        selecteds -= 1
+                    self.show_selector()
+                else:
+                    print(Controller.required_text("Indice inválido."))
+            else:
+                if selecteds == 0:
+                    print(Controller.required_text("Pelo menos um item deve ser selecionado."))
+                else:
+                    return
+
+
+    def create_structure(self):
+        if not "STRUCTURE" in self.current_file:
+            self.current_file["STRUCTURE"] = {}
+        return True
+
+
+    @Controller.clear_terminal
+    def create_classes(self):
+        self.create_structure()
+        if not "CLASSES" in self.current_file["STRUCTURE"]:
+            self.current_file["STRUCTURE"]["CLASSES"] = []
+
+        print(f"Iniciando registro de classes para o arquivo {Style.BRIGHT}{Fore.CYAN}{self.file}{Style.RESET_ALL}.")
+        while True:
+            current_class = {}
+            class_name = Controller.required_question(input)(Controller.required_text("Nome da classe: "))
+            current_class["name"] = class_name
+
+            is_initialized = Controller.required_question(input)(Controller.required_text("A classe possui um método __init__? (s/n): "))
+            if is_initialized.strip()[0].lower() == "s":
+                current_class["initializer"] = {}
+                current_class["initialized"] = True
+                while True:
+                    print(f"Digite os parâmetros do método __init__ (um por vez). {Style.DIM}Aperte CTRL-C para parar.")
+                    inputs = Controller.sequential_question(Controller.optional_text("> "))
+                    current_class["initializer"]["input"] = inputs if inputs else []
+
+                    class_info = input(Controller.optional_text(f"{CLEAR_LINE}Descrição da validação (instancialização da classe): "))
+                    if class_info.strip() != "":
+                        current_class["initializer"]["info"] = class_info
+                    break
+
+            while True:
+                add_method = Controller.required_question(input)(Controller.required_text("Deseja adicionar um método à classe? (s/n): "))
+                if add_method[0].lower() == "s":
+                    if not "methods" in current_class:
+                        current_class["methods"] = []
+                    method_data = {}
+
+                    method_name = Controller.required_question(input)(Controller.required_text("Nome do método: "))
+                    method_data["name"] = method_name
+
+                    print(f"Digite os parâmetros do método {Style.DIM}Aperte CTRL-C para parar.")
+                    method_inputs = Controller.sequential_question(Controller.optional_text("> "))
+                    method_data["input"] = method_inputs if method_inputs else []
+
+                    is_static = Controller.required_question(input)(Controller.required_text(f"{CLEAR_LINE}O método é estático? (s/n): "))
+                    method_data["static"] = True if is_static.strip()[0].lower() == "s" else False
+
+                    expected_output = input(Controller.optional_text("Output esperado: "))
+                    method_data["expected"] = expected_output if expected_output else ""
+
+                    method_info = input(Controller.optional_text("Descrição da validação: "))
+                    if method_info.strip() != "":
+                        method_data["info"] = method_info
+                    current_class["methods"].append(method_data)
+                else:
+                    break
+            
+            self.current_file["STRUCTURE"]["CLASSES"].append(current_class)
+            print(f"Classe {Style.BRIGHT}{Fore.CYAN}{class_name}{Style.RESET_ALL} adicionada com sucesso!")
+            new_class = Controller.required_question(input)(Controller.required_text("Deseja adicionar outra classe? (s/n): "))
+            if new_class.strip()[0].lower() != "s":
+                break
+            
+
+
+    @Controller.clear_terminal
+    def create_functions(self):
+        self.create_structure()
+        if not "FUNCTIONS" in self.current_file["STRUCTURE"]:
+            self.current_file["STRUCTURE"]["FUNCTIONS"] = []
+
+        print(f"Iniciando registro de funções para o arquivo {Style.BRIGHT}{Fore.CYAN}{self.file}{Style.RESET_ALL}.")
+        while True:
+            current_function = {}
+            function_name = Controller.required_question(input)(Controller.required_text("Nome da função: "))
+            current_function["name"] = function_name
+
+            print("Bateria de testes da função")
+            current_function["runs"] = []
+            while True:
+                current_run = {}
+
+                print(f"Digite os inputs necessários para testar a função. {Style.DIM}Aperte CTRL-C para parar.")
+                inputs = Controller.sequential_question(Controller.optional_text("> "))
+                current_run["input"] = inputs if inputs else []
+
+                expected = input(Controller.optional_text(f"{CLEAR_LINE}Output esperado: "))
+                current_run["expected"] = expected if expected else ""
+
+                info = input(Controller.optional_text("Descrição da validação: "))
+                if info.strip() != "":
+                    current_run["info"] = info
+
+                current_function["runs"].append(current_run)
+                new_run = Controller.required_question(input)(Controller.required_text("Deseja adicionar outra bateria de testes? (s/n): "))
+                if new_run.strip()[0].lower() != "s":
+                    break
+
+            self.current_file["STRUCTURE"]["FUNCTIONS"].append(current_function)
+            print(f"Função {Style.BRIGHT}{Fore.CYAN}{function_name}{Style.RESET_ALL} adicionada com sucesso!")
+
+            new_class = Controller.required_question(input)(Controller.required_text("Deseja adicionar outra função? (s/n): "))
+            if new_class.strip()[0].lower() != "s":
+                break
+        
+        
+
+    @Controller.clear_terminal
+    def create_cli(self):
+        self.current_file["CLI"] = []
+        print(f"Iniciando registro de CLI para o arquivo {Style.BRIGHT}{Fore.CYAN}{self.file}{Style.RESET_ALL}.")
+        while True:
+            current_cli = {}
+            inputs = input(Controller.optional_text("Argumentos do comando: "))
+            current_cli["input"] = inputs if inputs else ""
+
+            expected = input(Controller.optional_text("Output esperado: "))
+            current_cli["expected"] = expected if expected else ""
+
+            info = input(Controller.optional_text("Descrição da validação: "))
+            if info.strip() != "":
+                current_cli["info"] = info
+
+            self.current_file["CLI"].append(current_cli)
+            print(f"{Style.BRIGHT}{Fore.CYAN}Comando registrado com sucesso!")
+            new_run = Controller.required_question(input)(Controller.required_text("Deseja adicionar outro comando CLI? (s/n): "))
+            if new_run.strip()[0].lower() != "s":
+                break
+
+
+    @Controller.clear_terminal
+    def create_inputs(self):
+        print(f"Iniciando registro de inputs para o arquivo {Style.BRIGHT}{Fore.CYAN}{self.file}{Style.RESET_ALL}.")
+        self.current_file["INPUTS"] = []
+        while True:
+            current_seqinput = {}
+            print(f"Digite os inputs. {Style.DIM}Aperte CTRL-C para parar.")
+            inputs = Controller.sequential_question(Controller.optional_text("> "))
+            current_seqinput["input"] = inputs if inputs else []
+
+            print(f"{CLEAR_LINE}Digite os outputs esperados. {Style.DIM}Aperte CTRL-C para parar.")
+            expected = Controller.sequential_question(Controller.optional_text("> "))
+            current_seqinput["expected"] = expected if expected else []
+
+            info = input(Controller.optional_text(f"{CLEAR_LINE}Descrição da validação: "))
+            if info.strip() != "":
+                current_seqinput["info"] = info
+
+            self.current_file["INPUTS"].append(current_seqinput)
+            print(f"{Style.BRIGHT}{Fore.CYAN}Input registrado com sucesso!")
+            new_run = Controller.required_question(input)(Controller.required_text("Deseja adicionar outro input? (s/n): "))
+            if new_run.strip()[0].lower() != "s":
+                break
+
+
+    def purge_unselected(self):
+        selected = []
+        for selector in self.selectors:
+            if selector.selected:
+                selected.append(selector)
+        self.selectors = selected
+
+
+    def run_selected(self):
+        for selector in self.selectors:
+            selector.action()
+
+
+    def show_progress(self):
+        if not hasattr(self, 'progress_visualizer'):
+            self.progress_visualizer = copy.deepcopy(self.current_file)
+        visualizer = self.progress_visualizer
+        if "STRUCTURE" in visualizer:
+            for key in visualizer["STRUCTURE"]:
+                visualizer[key] = visualizer["STRUCTURE"][key]
+            del visualizer["STRUCTURE"]
+        
+        TUI([f"{Fore.CYAN}{self.file}", *({f"{Fore.CYAN}[{index+1}]": f"{Fore.GREEN}{key}{Style.RESET_ALL} {self.current_file[key]}"} for index, key in enumerate(self.current_file.keys()))], max_line=50).show()
+    
+
+    def start(self):
+        self.get_selectors()
+        self.purge_unselected()
+        self.run_selected()
+        self.show_progress()
+
+
+class Builder:
+    default_info =[
+        f"{Fore.YELLOW}{Style.BRIGHT}Gerador de {settings.get_config('answers_file_name')}",
+        f"{Style.DIM}Seu progresso vai ficar aqui.",
+        {
+            f"{Style.BRIGHT}{Fore.RED}Informações importantes:": "", 
+            f"{Style.BRIGHT}{Fore.CYAN}1.": "Leia atentamente a todos os avisos e instruções antes de prosseguir.", 
+            f"{Style.BRIGHT}{Fore.CYAN}2.": f"Inputs {Fore.RED}VERMELHOS{Style.RESET_ALL} são obrigatórios, enquanto inputs {Fore.YELLOW}AMARELOS{Style.RESET_ALL} são opcionais.", 
+            f"{Style.BRIGHT}{Fore.CYAN}3.": f"Alguns inputs exigem uma sequência de informções. Esses serão indicados com {Style.BRIGHT}setas (>){Style.RESET_ALL}.\nPara esse tipo de input, digite cada informação e aperte ENTER para confirmar. Inputs registrados com sucesso ficarão {Fore.GREEN}verdes{Style.RESET_ALL}.\nPara parar de adicionar informações, aperte {Style.BRIGHT}CTRL-C{Style.RESET_ALL} (salvo em situações que explicitamente indiquem o contrário).",
+        }
+    ]
+
+    @staticmethod
+    def confirm_yield():
+        input("Pressione ENTER para continuar...")
+
+    def __init__(self):
+        self.build = {}
+        self.info = TUI(self.default_info, max_line=80)
+    
+    @Controller.clear_terminal
+    def show_info(self):
+        self.info.show()
+    
+    def add_block(self, name: str, content: str):
+        self.build[name] = content
+
+    def show_progress(self, name: str, text: str):
+        progress = self.info.contents[1]
+        if not isinstance(progress, dict):
+            progress = {}
+
+        progress[f"{Style.BRIGHT}{name}"] = text
+        self.info.contents[1] = progress
+
+        self.show_info()
+
+    def get_files(self):
+        files = []
+
+        def format_filename(filename: str) -> str:
+            if not filename.endswith(".py"):
+                filename += ".py"
+            return filename
+
+        def get_extra_files() -> list:
+            extra_files = []
+            while True:
+                extra_file = input(f"{Controller.optional_text('> ')}")
+                if extra_file.strip() != "":
+                    extra_files.append(format_filename(extra_file))
+                else:
+                    break
+            return extra_files
+
+        print(f"\nNomeie os arquivos que você quer analisar. O primeiro arquivo é obrigatório.\n{Fore.YELLOW}OBSERVAÇÃO: A extensão .py será adicionada automaticamente.")
+        files.append(format_filename(Controller.required_question(input)(f"{Controller.required_text('Nome do primeiro arquivo: ')}")))
+        print(f"\nSe quiser adicionar mais arquivos, digite o nome deles um por vez.\n{Style.DIM}Para parar aperte ENTER sem digitar nada.")
+        files.extend(get_extra_files())
+        
+        return list(dict.fromkeys(files))
+
+
+    @Controller.clear_terminal
+    def save_file(self):
+        assignment_name = Controller.required_question(input)(f"{Controller.required_text('Nome da atividade: ')}")
+        save_path = Path.cwd() / assignment_name
+
+        print(f"O arquivo \"correcao.json\" será salvo em {save_path}.")
+        change_path = input(f"{Controller.optional_text('Deseja alterar o caminho? (s/n): ')}")
+
+        if change_path and change_path.strip()[0].lower() == "s":
+            user_input = Controller.required_question(input)(f"{Controller.required_text('Novo caminho: ')}")
+            save_path = Path(user_input)
+
+        file_path = save_path / "correcao.json"
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+
+        with open(file_path, "w", encoding="utf-8") as file:
+            json.dump(self.build, file, indent=4, ensure_ascii=False)
+
+        print(f"Arquivo salvo em {file_path}.")
+
+    def start(self):
+        try:
+            self.show_info()
+
+            self.confirm_yield()
+            files = self.get_files()
+            self.add_block("files", files)
+            self.show_progress("Arquivos selecionados: ", f"{'; '.join(files)}.")
+            self.confirm_yield()
+
+            Controller.clear_command()
+            for file in files:
+                fb = FileBuilder(file)
+                fb.start()
+                self.add_block(file, fb.current_file)
+
+                self.confirm_yield()
+
+            self.save_file()
+        except KeyboardInterrupt:
+            Controller.clear_command()
+            print(f"{Fore.RED}Operação cancelada pelo usuário. Nenhum arquivo foi salvo.")

{verifica-1.0.0.dev2 → verifica-1.0.2}/src/verifica/check.py

@@ -7,32 +7,45 @@ import sys
 from types import SimpleNamespace
 
 from . import imports_tester
-from .config import settings
 
 class Checker:
+    """Classe responsável por validar exercícios baseado em um arquivo de correção"""
 
-    def __init__(self, exercises_path: str, answers: dict):
+    def __init__(self, exercises_path: str, answers: dict) -> None:
         """Atribui os parâmetros passados para o objeto
-        
-        :param exercises_path: Caminho da pasta com arquivos do exercício
-        :param answers: Dicionário de respostas no formato apropriado
+
+        Args:
+            exercises_path (str): Caminho da pasta com arquivos do exercício
+            answers (dict): Dicionário de respostas no formato apropriado
         """
         self.exercises_path = exercises_path
         self.answers = answers
         self.roadmap = []
         self.logger = logging.getLogger(__name__)
+
     
     def __file_exists(self, file_path: str) -> bool:
         """Checa se um arquivo existe em determinado caminho
 
-        :param file_path: Caminho do arquivo
-        :returns: Verdadeiro caso exista
-        :rtype: bool
+        Args:
+            file_path (str): Caminho do arquivo
+
+        Returns:
+            bool: Booleano indicando se o arquivo existe
         """
         return Path(self.exercises_path / file_path).is_file()
 
+
     def setup_roadmap(self) -> bool:
-        """Popula a lista roadmap com uma sequência de testes a serem realizados"""
+        """Popula a lista roadmap com uma sequência de testes a serem realizados
+
+        Raises:
+            ValueError: Arquivo de correção não possui características a serem testadas
+            ValueError: Característica desconhecida no arquivo de correção
+
+        Returns:
+            bool: Booleano indicando se o roadmap foi configurado com sucesso
+        """
         try:
             self.logger.info(f"Configurando roadmap")
             for file in self.answers["files"]:
@@ -70,7 +83,8 @@ class Checker:
                             for class_info in subsequent_steps["CLASSES"]:
                                 self.logger.info(f"ADICIONANDO CLASSE {class_info['name']}")
                                 is_initialized = class_info.get("initialized", False)
-                                currentClass = imports_tester.ClassTester(importedFile, class_info["name"], class_info["methods"], is_initialized)
+                                has_methods = class_info.get("methods", []) != []
+                                currentClass = imports_tester.ClassTester(importedFile, class_info["name"], class_info["methods"] if has_methods else [], is_initialized)
                                 self.roadmap.append({
                                     "info": class_info.get("info", f"classe {class_info['name']} existe e possui os métodos esperados"),
                                     "args": [currentClass],
@@ -79,15 +93,16 @@ class Checker:
                                 if is_initialized:
                                     self.roadmap.append({
                                         "info": class_info.get("info", f"classe {class_info['name']} pode ser instanciada"),
-                                        "args": [currentClass, *class_info["initializer"]["args"]],
+                                        "args": [currentClass, *class_info["initializer"]["input"]],
                                         "action": imports_tester.ClassTester.initialize_instance
                                     })
-                                for method_info in class_info["methods"]:
-                                    self.roadmap.append({
-                                        "info": method_info.get("info", f"{method_info['name']}({', '.join(map(str, method_info['input']))}) retorna {method_info['expected']}"),
-                                        "args": [method_info["name"], method_info.get("static", False), method_info["input"], method_info["expected"]],
-                                        "action": currentClass.test_method
-                                    })
+                                if has_methods:
+                                    for method_info in class_info["methods"]:
+                                        self.roadmap.append({
+                                            "info": method_info.get("info", f"{method_info['name']}({', '.join(map(str, method_info['input']))}) retorna {method_info['expected']}"),
+                                            "args": [method_info["name"], method_info.get("static", False), method_info["input"], method_info["expected"]],
+                                            "action": currentClass.test_method
+                                        })
                         if subsequent_steps.get("FUNCTIONS"):
                             self.logger.info(f"FUNÇÕES DETECTADAS")
                             for function_info in subsequent_steps["FUNCTIONS"]:
@@ -105,21 +120,22 @@ class Checker:
                                         "args": [currentFunction, run["input"], run["expected"]],
                                         "action": imports_tester.FunctionTester.test
                                     })
-                    elif check_step == "INPUTS":
-                        for input_info in subsequent_steps:
-                            self.logger.info(f"ADICIONANDO INPUT {input_info['input']}")
-                            self.roadmap.append({
-                                "info": input_info.get("info", f"input '{input_info['input']}' retorna '{input_info['expected']}'"),
-                                "args": [current_file_path, input_info["input"], input_info["expected"]],
-                                "action": self.test_INPUT
-                            })
-                    elif check_step == "SEQUENCE_INPUTS":
+                    elif check_step == "INPUTS" or check_step == "SEQUENCE_INPUTS":
                         for sequence_input_info in subsequent_steps:
-                            self.logger.info(f"ADICIONANDO SEQUENCE_INPUTS {sequence_input_info['input']}")
+                            self.logger.info(f"ADICIONANDO INPUTS {sequence_input_info['input']}")
+
+                            expected = sequence_input_info['expected']
+                            input_data = sequence_input_info['input']
+
+                            if isinstance(expected, str):
+                                expected = [expected]
+                            if isinstance(input_data, str):
+                                input_data = [input_data]
+
                             self.roadmap.append({
-                                "info": sequence_input_info.get("info", f"input '{', '.join(sequence_input_info['input'])}' retorna '{', '.join(sequence_input_info['expected'])}'"),
-                                "args": [current_file_path, sequence_input_info["input"], sequence_input_info["expected"]],
-                                "action": self.test_SEQUENCE_INPUT
+                                "info": sequence_input_info.get("info", f"input '{', '.join(input_data)}' retorna '{', '.join(expected)}'"),
+                                "args": [current_file_path, input_data, expected],
+                                "action": self.test_INPUTS
                             })
                     else:
                         raise ValueError(f"Característica desconhecida '{check_step}' no arquivo de correção")
@@ -135,65 +151,104 @@ class Checker:
 
 
     def test_CLI(self, file_path: str, input_args: list[str], expected_output: str) -> bool:
-        try:
-            result = subprocess.run([sys.executable, file_path] + input_args, capture_output=True, text=True)
-            self.logger.warning(f"Saída do comando '{' '.join(input_args)}': {result.stdout.strip()}")
-            return expected_output in result.stdout.strip()
-        except subprocess.CalledProcessError as e:
-            self.logger.warning(f"O script '{input_args[0]}' falhou com o código de saída {e.returncode}")
-            self.logger.warning(f"Detalhes do erro: {e.stderr}")
-            return False
+        """Testa um comando CLI de um programa Python
+
+        Args:
+            file_path (str): Caminho do arquivo a ser testado
+            input_data (list[str]): Lista de inputs a serem fornecidos ao programa
+            expected_output (str): Saída esperada
 
-    def test_INPUT(self, file: str, input_data: str, expected_output: str) -> bool:
+        Returns:
+            bool: Booleano indicando se a saída do programa contém a saída esperada
+        """
         try:
             result = subprocess.run(
-                [sys.executable, file], 
-                input=input_data, 
+                [sys.executable, file_path] + input_args, 
                 capture_output=True, 
                 text=True
             )
-            return expected_output in result.stdout.strip()
-        except subprocess.CalledProcessError as e:
-            self.logger.warning(f"A ação do input '{input_data}' falhou com o código de saída {e.returncode}")
-            self.logger.warning(f"Detalhes do erro: {e.stderr}")
+
+            if result.returncode != 0:
+                self.logger.warning(
+                    f"[CLI] O programa terminou com código {result.returncode}"
+                )
+                self.logger.warning(f"[CLI] stderr: {result.stderr}")
+                return False
+
+            output = result.stdout.strip()
+            self.logger.debug(f"[CLI] Saída do comando '{' '.join(input_args)}': {output}")
+
+            return expected_output in output
+
+        except Exception as e:
+            self.logger.warning(
+                f"[CLI] Falha ao executar o comando '{file_path} {' '.join(input_args)}': {e}"
+            )
             return False
 
-    def test_SEQUENCE_INPUT(self, file: str, input_data: list[str], expected_output: list[str]) -> bool:
+    def test_INPUTS(self, file_path: str, input_data: list[str], expected_output: list[str]) -> bool:
+        """Testa uma sequência de inputs
+
+        Args:
+            file_path (str): Caminho do arquivo a ser testado
+            input_data (list[str]): Lista de inputs a serem fornecidos ao programa
+            expected_output (list[str]): Lista de saídas esperadas
+
+        Returns:
+            bool: Booleano indicando se a saída do programa contém a saída esperada
+        """
         try:
             result = subprocess.run(
-                [sys.executable, file], 
-                input=("\n").join(input_data), 
-                capture_output=True, 
+                [sys.executable, file_path],
+                input="\n".join(input_data) + "\n",
+                capture_output=True,
                 text=True
             )
+
+            if result.returncode != 0:
+                self.logger.warning(
+                    f"[INPUT] O programa terminou com código {result.returncode}"
+                )
+                self.logger.warning(f"[INPUT] stderr: {result.stderr}")
+                return False
+
             output = result.stdout.strip()
-            return all(palavra in output for palavra in expected_output)
-        except subprocess.CalledProcessError as e:
-            self.logger.warning(f"A ação do input múltiplo '{input_data}' falhou com o código de saída {e.returncode}")
-            self.logger.warning(f"Detalhes do erro: {e.stderr}")
+            self.logger.debug(f"[INPUT] Saída do input: {output}")
+
+            return all(
+                expected in output
+                for expected in expected_output
+            )
+
+        except Exception as e:
+            self.logger.warning(
+                f"[INPUT] Falha ao executar o input '{input_data}': {e}"
+            )
             return False
 
+    
     def make_result_message(self, result: bool, info: str) -> str:
-        """Gera uma mensagem de resultado formatada com cores
+        """Forma uma mensagem de resultado com cores e estilo apropriados
+
+        Args:
+            result (bool): Resultado do teste
+            info (str): Informação sobre o teste
 
-        :param result: Resultado do teste
-        :param info: Informação sobre o teste
-        :returns: Mensagem formatada
-        :rtype: str
+        Returns:
+            str: Mensagem formatada
         """
         colors = {
-            True: Fore.GREEN if settings.enviroment_supports_colors else "",
-            False: Fore.RED if settings.enviroment_supports_colors else "",
-            "bold": Style.BRIGHT if settings.enviroment_supports_colors else "",
-            "reset": Style.RESET_ALL if settings.enviroment_supports_colors else ""
+            True: Fore.GREEN,
+            False: Fore.RED
         }
-        return f"{colors[result]}{colors['bold']}{':)' if result else ':('}{colors['reset']} {colors[result]}{info}{colors['reset']}"
+        return f"{colors[result]}{Style.BRIGHT}{':)' if result else ':('}{Style.RESET_ALL} {colors[result]}{info}{Style.RESET_ALL}"
+
 
     def run_roadmap(self) -> list:
         """Executa os testes do roadmap e retorna uma lista de resultados
 
-        :returns: Lista de resultados dos testes
-        :rtype: list
+        Returns:
+            list: Lista de resultados dos testes
         """
         results = []
         for step in self.roadmap:
@@ -208,10 +263,12 @@ class Checker:
 
         return results
 
+    
     def show_results(self, results: list) -> None:
         """Exibe os resultados dos testes no console
 
-        :param results: Lista de resultados dos testes
+        Args:
+            results (list): Lista de resultados dos testes
         """
         if self.answers.get("description"):
             print(f"{self.answers['description']}")

{verifica-1.0.0.dev2 → verifica-1.0.2}/src/verifica/config.py

@@ -1,18 +1,9 @@
 from platformdirs import user_config_dir
 from importlib.metadata import version, PackageNotFoundError
-from colorama import init
 from time import time
 import json
-import sys
 import os
 
-def setup_colors():
-    if not sys.stdout.isatty():
-        init(strip=True, convert=False)
-        return False
-    
-    init(autoreset=True)
-    return True
 
 class Config:
     _instance = None
@@ -26,7 +17,6 @@ class Config:
         if hasattr(self, "_initialized"):
             return
         self._initialized = True
-        self.enviroment_supports_colors = setup_colors()
 
         config_dir = user_config_dir("verifica")
         os.makedirs(config_dir, exist_ok=True)
@@ -49,13 +39,8 @@ class Config:
                 return {}
 
     def __check_config_state(self):
-        try:
-            current_version = version("verifica")
-        except PackageNotFoundError:
-            current_version = f"indev-{time()}"
-
         defaultConfig = {
-            "version": current_version,
+            "version": self.get_version(),
             "url": "https://raw.githubusercontent.com",
             "answers_file_name": "correcao.json"
         }
@@ -67,6 +52,13 @@ class Config:
             if current_config.get("version") != defaultConfig.get("version"):
                 self.update_config(defaultConfig, defaultConfig.get("version"))
 
+    def get_version(self):
+        try:
+            __version__  = version("verifica")
+        except PackageNotFoundError:
+            __version__  = f"indev-{time()}"
+        return __version__
+
     def update_config(self, new_data: dict, version: str = None):
         current_config = self.__read_keys()
         if version:

{verifica-1.0.0.dev2 → verifica-1.0.2}/src/verifica/fetcher.py

@@ -68,7 +68,14 @@ class Fetcher:
         if not self.file:
             raise ValueError("o arquivo de correção não existe")
 
-        return json.loads(self.get_content())
+        try:
+            decoded = json.loads(self.get_content())
+        except json.JSONDecodeError as error:
+            self.logger.error(f"Falha ao decodificar o arquivo de correção '{self.exercise}': {error}")
+            raise RuntimeError(f"Falha ao decodificar o arquivo de correção '{self.exercise}'") from error
+
+        return decoded
+
 
     def cleanup(self):
         if self.file != None:

{verifica-1.0.0.dev2 → verifica-1.0.2}/src/verifica/imports_tester.py

@@ -39,7 +39,7 @@ class Imported:
                 raise ImportError(f"Falha ao importar o módulo '{module_path}'") from e
 
 class ClassTester:
-    def __init__(self, import_info: Imported, class_name: str, methods: list, initialized: bool):
+    def __init__(self, import_info: Imported, class_name: str, methods: list = [], initialized: bool = False):
         self.import_info = import_info
         self.class_name = class_name
         self.methods = methods

verifica-1.0.2/src/verifica/tui.py

@@ -0,0 +1,104 @@
+from colorama import Style
+import re
+
+# Regex para códigos ANSI de cores e formatação
+ANSI_PATTERN = re.compile(r"(\x9B|\x1B\[)[0-?]*[ -/]*[@-~]")
+
+class TUI:
+    @staticmethod
+    def visible_len(text: str) -> int:
+        """Retorna o tamanho de uma string sem caracteres de formatação ANSI"""
+        return len(ANSI_PATTERN.sub("", text))
+
+    def __init__(self, contents: list, show: bool = False, max_line: int = -1, padding: int = 1):
+        self.contents = contents
+        self.padding = padding
+        self.max_line = max_line
+        self.min_size = self.__get_longest_message_length() + (padding * 2)
+        self.row_size = self.min_size + self.padding
+        if show:
+            self.show()
+
+    def __get_longest_message_length(self):
+        longest = 0
+        for block in self.contents:
+            if isinstance(block, dict):
+                for k, v in block.items():
+                    for line in self.__get_paragraphs(k, self.__create_paragraphs(k, v)):
+                        length = self.visible_len(line)
+                        if length > longest:
+                            longest = length
+            else:
+                length = self.visible_len(block)
+                if length > longest:
+                    longest = length
+        return longest
+
+    def __get_paragraphs(self, key: str, text: str) -> list:
+        lines = []
+        paragraphs = text.split('\n')
+
+        lines.append(f"{key}{Style.RESET_ALL} {paragraphs[0]}")
+        for paragraph in paragraphs[1:]:
+            lines.append(f"{' ' * (self.visible_len(key) + 1)}{paragraph}{Style.RESET_ALL}")
+
+        return lines
+
+    def __create_paragraphs(self, key: str, text: str) -> str:
+        if self.max_line >= 1:
+            paragraphs = []
+            unformatted_paragraphs = text.split('\n')
+
+            for paragraph in unformatted_paragraphs:
+                words = paragraph.split()
+                current_line = ""
+                for word in words:
+                    if self.visible_len(f"{key} {current_line}") + self.visible_len(word) + 1 <= self.max_line:
+                        current_line += f"{word} "
+                    else:
+                        paragraphs.append(current_line.strip())
+                        current_line = f"{word} "
+
+                if current_line:
+                    paragraphs.append(current_line.strip())
+
+            return '\n'.join(paragraphs)
+        return [text]
+
+    def __create_top_border(self):
+        return f"╔{'═' * self.row_size}╗"
+
+    def __create_internal_border(self):
+        return f"╠{'═' * self.row_size}╣"
+
+    def __create_bottom_border(self):
+        return f"╚{'═' * self.row_size}╝"
+
+    def __create_left_border(self):
+        return f"║"
+
+    def __create_right_border(self):
+        return f"║"
+
+    def __create_center_row(self, text: str):
+        return f"{self.__create_left_border()}{" "*self.padding}{text.center(self.min_size - self.padding + (len(text) - self.visible_len(text)))}{Style.RESET_ALL}{" "*self.padding}{self.__create_right_border()}"
+
+    def __create_row(self, text: str):
+        return f"{self.__create_left_border()}{" "*self.padding}{text.ljust(self.min_size - self.padding + (len(text) - self.visible_len(text)))}{" "*self.padding}{Style.RESET_ALL}{self.__create_right_border()}"
+
+    def show(self):
+        last_element = len(self.contents) - 1
+        
+        print(f"{self.__create_top_border()}")
+        for index, block in enumerate(self.contents):
+            if isinstance(block, dict):
+                for key, message in self.contents[index].items():
+                    for line in self.__get_paragraphs(key, self.__create_paragraphs(key, message)):
+                        print(f"{self.__create_row(line)}")
+            else:
+                print(f"{self.__create_center_row(block)}")
+                
+            if index != last_element:
+                print(f"{self.__create_internal_border()}")
+            else:
+                print(f"{self.__create_bottom_border()}")

{verifica-1.0.0.dev2 → verifica-1.0.2/src/verifica.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: verifica
-Version: 1.0.0.dev2
+Version: 1.0.2
 Summary: Uma ferramenta simples para correção de atividades em python via CLI.
 Author-email: Théo Modeneis Ruela <theo.ruela@gmail.com>
 License-Expression: MIT
@@ -8,7 +8,7 @@ Project-URL: Homepage, https://github.com/espinafr/Verifica
 Project-URL: Issues, https://github.com/espinafr/Verifica/issues
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9.13
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: colorama>=0.4.6
@@ -24,9 +24,6 @@ Dynamic: license-file
                 <td><a href="https://pypi.org/project/verifica/">Página no Pypi</a></td>
                 <td align="right"><a href="https://github.com/espinafr/verifica/issues/new?template=denúncia-de-bug.yml">Reportar bug</a></td>
             </tr>
-            <tr>
-                <td colspan="2" align="center"><a href="https://espinafr.github.io/verifica">Gerador <code>correcao.json</code></a></td>
-            </tr>
             <tr>
                 <td colspan="2" align="center"><a href="https://github.com/espinafr/verifica/tree/master/docs">Como configurar</a></td>
             </tr>
@@ -74,7 +71,7 @@ pip install dist/{NOME DO ARQUIVO GERADO}
 
 ## Reconhecimentos
 
-Veja o arquivo [ACKNOWLEDGEMENTS](https://github.com/espinafr/verifica/blob/master/ACKNOWLEDGEMENTS.md)
+Veja o arquivo [ACKNOWLEDGEMENTS](https://github.com/espinafr/verifica/blob/master/ACKNOWLEDGEMENTS.md).
 
 ## Licença
 

{verifica-1.0.0.dev2 → verifica-1.0.2}/src/verifica.egg-info/SOURCES.txt

@@ -3,10 +3,12 @@ README.md
 pyproject.toml
 src/verifica/__init__.py
 src/verifica/__main__.py
+src/verifica/builder.py
 src/verifica/check.py
 src/verifica/config.py
 src/verifica/fetcher.py
 src/verifica/imports_tester.py
+src/verifica/tui.py
 src/verifica.egg-info/PKG-INFO
 src/verifica.egg-info/SOURCES.txt
 src/verifica.egg-info/dependency_links.txt