verifica 1.0.0__py3-none-any.whl

verifica/__main__.py

@@ -0,0 +1,85 @@
+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)
+    positional = parser.add_argument_group("argumentos posicionais")
+    options = parser.add_argument_group("opções")
+
+    positional.add_argument("atividade", nargs="?", help="A URL do github ou caminho local do arquivo usado para a correção da atividade.")
+    options.add_argument("-f", "--files", default=Path.cwd(), help="Diretório com a(s) atividade(s) a ser(em) corrigida(s).")
+    options.add_argument("-h", "--help", "--ajuda", action="help", help="Mostra essa mensagem de ajuda.")
+    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:
+        logging.getLogger().setLevel(logging.DEBUG)
+        logging.info("Modo debug ativado. Mostrando informações detalhadas durante a execução.")
+    
+    if args.config:
+        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")
+
+    if not args.local:
+        answers = Fetcher(args.atividade)
+        try:
+            print("Baixando arquivo de correção...")
+            logging.debug(f"CAMINHO DO ARQUIVO BAIXADO: {answers.fetch()}")
+        except Exception as e:
+            logging.error(f"Não foi possível localizar o arquivo de correção em '{args.atividade}'")
+            sys.exit(1)
+    else:
+        answers = Fetcher(args.atividade, local=True)
+        try:
+            print("Buscando arquivo de correção local...")
+            logging.debug(f"CAMINHO DO ARQUIVO LOCAL: {answers.get_file()}")
+        except Exception as e:
+            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()
+    answers.cleanup()
+
+    checker = Checker(args.files, decoded_answers)
+
+    checker.setup_roadmap()
+
+    results = checker.run_roadmap()
+    checker.show_results(results)
+    
+    sys.exit(0)
+
+if __name__ == "__main__":
+    main()

verifica/builder.py

@@ -0,0 +1,431 @@
+from pathlib import Path
+from colorama import Style, Fore
+from functools import wraps
+import subprocess
+import json
+import os
+
+from .tui import TUI
+from .config import settings
+
+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 sequential_question(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            answers = []
+            while True:
+                result = func(*args, **kwargs)
+                if result.strip() != "":
+                    answers.append(result)
+                else:
+                    return answers
+        return wrapper
+
+
+    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("Input", self.create_inputs),
+            Selector("Input sequencial", self.create_sequence_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 parâmetro que você quer analisar para o 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("Digite os parâmetros do método __init__ (um por vez). Para parar, aperte ENTER sem digitar nada: ")
+                    inputs = Controller.sequential_question(input)(Controller.optional_text("> "))
+                    current_class["initializer"]["input"] = inputs if inputs else []
+
+                    class_info = input(Controller.optional_text("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("Digite os parâmetros do método (um por vez). Para parar, aperte ENTER sem digitar nada: ")
+                    method_inputs = Controller.sequential_question(input)(Controller.optional_text("> "))
+                    method_data["input"] = method_inputs if method_inputs else []
+
+                    is_static = Controller.required_question(input)(Controller.required_text("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("Digite os inputs necessários para testar a função. Para parar, aperte ENTER sem digitar nada.")
+                inputs = Controller.sequential_question(input)(Controller.optional_text("> "))
+                current_run["input"] = inputs if inputs else []
+
+                expected = input(Controller.optional_text("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):
+        self.current_file["INPUTS"] = []
+        print(f"Iniciando registro de input simples para o arquivo {Style.BRIGHT}{Fore.CYAN}{self.file}{Style.RESET_ALL}.")
+        while True:
+            current_input = {}
+            text_input = input(Controller.optional_text("Input: "))
+            current_input["input"] = text_input
+
+            expected = input(Controller.optional_text("Expected Output: "))
+            current_input["expected"] = expected
+
+            info = input(Controller.optional_text("Descrição da validação: "))
+            if info.strip() != "":
+                current_input["info"] = info
+
+            self.current_file["INPUTS"].append(current_input)
+            print(f"{Style.BRIGHT}{Fore.CYAN}Input registrado com sucesso!")
+            new_run = Controller.required_question(input)(Controller.required_text("Deseja adicionar outro input simples? (s/n): "))
+            if new_run.strip()[0].lower() != "s":
+                break
+
+
+    @Controller.clear_terminal
+    def create_sequence_inputs(self):
+        print(f"Iniciando registro de inputs sequenciais para o arquivo {Style.BRIGHT}{Fore.CYAN}{self.file}{Style.RESET_ALL}.")
+        self.current_file["SEQUENCE_INPUTS"] = []
+        while True:
+            current_seqinput = {}
+            print("Aperte ENTER sem digitar nada para parar de registrar inputs.")
+            inputs = Controller.sequential_question(input)(Controller.optional_text("> "))
+            current_seqinput["input"] = inputs if inputs else []
+
+            print("Digite os outputs esperados. Aperte ENTER sem digitar nada para parar.")
+            expected = Controller.sequential_question(input)(Controller.optional_text("> "))
+            current_seqinput["expected"] = expected if expected else []
+
+            info = input(Controller.optional_text("Descrição da validação: "))
+            if info.strip() != "":
+                current_seqinput["info"] = info
+
+            self.current_file["SEQUENCE_INPUTS"].append(current_seqinput)
+            print(f"{Style.BRIGHT}{Fore.CYAN}Input sequencial registrado com sucesso!")
+            new_run = Controller.required_question(input)(Controller.required_text("Deseja adicionar outro input sequencial? (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):
+        TUI([f"{Fore.CYAN}{self.file}", *({f"{Fore.CYAN}[{index+1}]": f"{Fore.GREEN}{key}{Style.RESET_ALL}\n{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 {Fore.GREEN}setas coloridas (>){Style.RESET_ALL}. Quando quiser parar de adicionar informações, basta apertar {Style.BRIGHT}ENTER{Style.RESET_ALL} sem digitar nada enquanto a seta estiver {Fore.YELLOW}AMARELA (>){Style.RESET_ALL}.",
+        }
+    ]
+
+    @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
+
+        print(f"Vamos começar nomeando os arquivos que você quer analisar. O primeiro arquivo é obrigatório, então digite o nome dele e aperte ENTER.\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("Perfeito! Agora, se quiser adicionar mais arquivos, digite o nome deles um por vez. Para parar aperte ENTER sem digitar nada.")
+        files.extend(list(map(format_filename, Controller.sequential_question(input)(f"{Controller.optional_text('> ')}"))))
+        
+        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):
+        self.show_info()
+
+        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()

verifica/check.py

@@ -0,0 +1,218 @@
+from colorama import Fore, Style
+from pathlib import Path
+import subprocess
+import traceback
+import logging
+import sys
+from types import SimpleNamespace
+
+from . import imports_tester
+
+class Checker:
+
+    def __init__(self, exercises_path: str, answers: dict):
+        """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
+        """
+        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
+        """
+        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"""
+        try:
+            self.logger.info(f"Configurando roadmap")
+            for file in self.answers["files"]:
+                current_file_path = Path(self.exercises_path) / file
+                self.logger.info(f"Inicindo detecções para o arquivo '{file}'")
+
+                if len(self.answers[file]) == 0:
+                    raise ValueError(f"O arquivo de correção para '{file}' não possui características a serem testadas")
+
+                self.logger.info(file)
+                self.roadmap.append({
+                    "info": f"'{file}' existe",
+                    "args": [self, file],
+                    "action": Checker.__file_exists
+                })
+
+                for check_step, subsequent_steps in self.answers[file].items():
+                    self.logger.info(f"CARACTERÍSTICA DETECTADA: {check_step}")
+                    if check_step == "CLI":
+                        for command in subsequent_steps:
+                            self.logger.info(f"ADICIONANDO COMANDO CLI: {file} {command['input']}")
+                            self.roadmap.append({
+                                "info": command.get("info", f"comando '{command['input']}' retorna '{command['expected']}'"),
+                                "args": [self, current_file_path, command["input"].split(" "), command["expected"]],
+                                "action": Checker.test_CLI
+                            })
+                    elif check_step == "STRUCTURE":
+                        try:
+                            importedFile = imports_tester.Imported(current_file_path)
+                        except Exception as e:
+                            self.logger.warning(f"Falha ao importar o arquivo '{file}': {e}")
+                            importedFile = SimpleNamespace(module=None, logger=self.logger)
+                        if subsequent_steps.get("CLASSES"):
+                            self.logger.info(f"CLASSES DETECTADAS")
+                            for class_info in subsequent_steps["CLASSES"]:
+                                self.logger.info(f"ADICIONANDO CLASSE {class_info['name']}")
+                                is_initialized = class_info.get("initialized", False)
+                                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],
+                                    "action": imports_tester.ClassTester.get_existance
+                                })
+                                if is_initialized:
+                                    self.roadmap.append({
+                                        "info": class_info.get("info", f"classe {class_info['name']} pode ser instanciada"),
+                                        "args": [currentClass, *class_info["initializer"]["input"]],
+                                        "action": imports_tester.ClassTester.initialize_instance
+                                    })
+                                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"]:
+                                self.logger.info(f"ADICIONANDO FUNÇÃO {function_info['name']}")
+                                currentFunction = imports_tester.FunctionTester(importedFile, function_info["name"])
+                                self.roadmap.append({
+                                    "info": function_info.get("info", f"função {function_info['name']} existe"),
+                                    "args": [currentFunction],
+                                    "action": imports_tester.FunctionTester.get_existance
+                                })
+                                for run in function_info["runs"]:
+                                    self.logger.info(f"ADICIONANDO RUN {function_info['name']}({', '.join(map(str, run['input']))})")
+                                    self.roadmap.append({
+                                        "info": run.get("info", f"função {function_info['name']}({', '.join(map(str, run['input']))}) retorna {run['expected']}"),
+                                        "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":
+                        for sequence_input_info in subsequent_steps:
+                            self.logger.info(f"ADICIONANDO SEQUENCE_INPUTS {sequence_input_info['input']}")
+                            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
+                            })
+                    else:
+                        raise ValueError(f"Característica desconhecida '{check_step}' no arquivo de correção")
+        except (ValueError, KeyError) as e:
+            self.logger.error(f"Estrutura do arquivo de correção inválida para o arquivo '{file}'.\nDetalhes: {e}")
+            return False
+        except Exception as e:
+            self.logger.error(f"Erro ao configurar roadmap para o arquivo '{file}'.")
+            self.logger.error(f"Detalhes do erro: {e}\n{traceback.format_exc()}")
+            return False
+
+        return True
+
+
+    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
+
+    def test_INPUT(self, file: str, input_data: str, expected_output: str) -> bool:
+        try:
+            result = subprocess.run(
+                [sys.executable, file], 
+                input=input_data, 
+                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}")
+            return False
+
+    def test_SEQUENCE_INPUT(self, file: str, input_data: list[str], expected_output: list[str]) -> bool:
+        try:
+            result = subprocess.run(
+                [sys.executable, file], 
+                input=("\n").join(input_data), 
+                capture_output=True, 
+                text=True
+            )
+            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}")
+            return False
+
+    def make_result_message(self, result: bool, info: str) -> str:
+        """Gera uma mensagem de resultado formatada com cores
+
+        :param result: Resultado do teste
+        :param info: Informação sobre o teste
+        :returns: Mensagem formatada
+        :rtype: str
+        """
+        colors = {
+            True: Fore.GREEN,
+            False: Fore.RED
+        }
+        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
+        """
+        results = []
+        for step in self.roadmap:
+            try:
+                self.logger.debug(step["args"])
+                result = step["action"](*step["args"])
+            except Exception as e:
+                result = False
+                self.logger.warning(f"Erro ao executar o teste '{step['info']}': {e}\n{traceback.format_exc()}")
+            
+            results.append(self.make_result_message(result, step["info"]))
+
+        return results
+
+    def show_results(self, results: list) -> None:
+        """Exibe os resultados dos testes no console
+
+        :param results: Lista de resultados dos testes
+        """
+        if self.answers.get("description"):
+            print(f"{self.answers['description']}")
+        for result in results:
+            print(result)

verifica/config.py

@@ -0,0 +1,80 @@
+from platformdirs import user_config_dir
+from importlib.metadata import version, PackageNotFoundError
+from time import time
+import json
+import os
+
+
+class Config:
+    _instance = None
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls, *args, **kwargs)
+        return cls._instance
+
+    def __init__(self):
+        if hasattr(self, "_initialized"):
+            return
+        self._initialized = True
+
+        config_dir = user_config_dir("verifica")
+        os.makedirs(config_dir, exist_ok=True)
+
+        self.config_dir = config_dir
+        self.config_path = os.path.join(config_dir, "config.toml")
+        self.__check_config_state()
+
+    def __save_keys(self, data: dict):
+        with open(self.config_path, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=4)
+
+    def __read_keys(self) -> dict:
+        if not self.config_path or not os.path.exists(self.config_path):
+            return {}
+        with open(self.config_path, "r", encoding="utf-8") as f:
+            try:
+                return json.load(f)
+            except json.decoder.JSONDecodeError:
+                return {}
+
+    def __check_config_state(self):
+        defaultConfig = {
+            "version": self.get_version(),
+            "url": "https://raw.githubusercontent.com",
+            "answers_file_name": "correcao.json"
+        }
+
+        current_config = self.__read_keys()
+        if len(current_config) == 0:
+            self.__save_keys(defaultConfig)
+        else:
+            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:
+            current_config["version"] = version
+        new_data.update(current_config)
+        self.__save_keys(new_data)
+
+    def get_config(self, key: str = None) -> dict:
+        config = self.__read_keys()
+        if key:
+            return config.get(key, "")
+        return config
+
+    def set_config(self, key: str, value):
+        config = self.__read_keys()
+        config[key] = value
+        self.update_config(config)
+
+settings = Config()

verifica/fetcher.py

@@ -0,0 +1,75 @@
+from pathlib import Path
+from urllib.error import HTTPError, URLError
+from urllib.request import Request, urlopen
+import tempfile
+import logging
+import json
+
+from .config import settings
+
+class Fetcher:
+    def __init__(self, path, local: bool = False):
+        self.exercise = path
+        self.local = local
+        if not local:
+            self.base_url = settings.get_config("url")
+            self.remote_path = f"{self.exercise.strip()}/{settings.get_config('answers_file_name')}"
+        self.logger = logging.getLogger(__name__)
+
+    def __str__(self):
+        return f"Fetcher(url=\"{self._build_url()}\")"
+
+    def _build_url(self):
+        return f"{self.base_url}/{self.remote_path}"
+
+    def fetch(self) -> str:
+        """Baixa o arquivo de respostas e salva em uma pasta temporária
+
+        :returns: O caminho do arquivo salvo
+        :rtype: str
+        :raises RuntimeError: Se não for possível buscar o exercício
+        """
+        try:
+            self.logger.info("Baixando arquivo de correção...")
+            request = Request(self._build_url())
+
+            request.add_header("Cache-Control", "no-cache, no-store, must-revalidate")
+            request.add_header("Pragma", "no-cache")
+            request.add_header("Expires", "0")
+
+            with urlopen(request) as response:
+                content = response.read().decode("utf-8")
+        except (HTTPError, URLError) as error:
+            self.logger.error(f"Falha ao buscar o arquivo de correção '{self.exercise}': {error}")
+            raise RuntimeError(f"Falha ao buscar o arquivo de correção '{self.exercise}'") from error
+
+        self.file = tempfile.NamedTemporaryFile(mode='w+t', prefix='verifica-', suffix='.json', encoding='utf-8')
+        self.file.write(content)
+
+        return self.file.name
+
+    def get_file(self):
+        if self.local:
+            local_path = Path(self.exercise) / settings.get_config("answers_file_name")
+            if not local_path.is_file():
+                raise FileNotFoundError(f"O arquivo de respostas não foi encontrado em '{local_path}'")
+            self.file = open(local_path, 'r', encoding='utf-8')
+            return str(local_path)
+
+
+    def get_content(self):
+        if not self.file:
+            raise ValueError("o arquivo de correção não existe")
+
+        self.file.seek(0)
+        return self.file.read()
+
+    def get_decoded_json(self):
+        if not self.file:
+            raise ValueError("o arquivo de correção não existe")
+
+        return json.loads(self.get_content())
+
+    def cleanup(self):
+        if self.file != None:
+            self.file.close()

verifica/imports_tester.py

@@ -0,0 +1,146 @@
+import importlib.util
+import logging
+import traceback
+from contextlib import redirect_stderr, redirect_stdout
+from io import StringIO
+
+def _call_with_captured_output(callable_obj, *args, **kwargs):
+    stdout_buffer = StringIO()
+    stderr_buffer = StringIO()
+    with redirect_stdout(stdout_buffer), redirect_stderr(stderr_buffer):
+        result = callable_obj(*args, **kwargs)
+
+    return result, stdout_buffer.getvalue().strip(), stderr_buffer.getvalue().strip()
+
+class Imported:
+    def __init__(self, module_path: str):
+        self.logger = logging.getLogger(__name__)
+        self.module = self.__import_module(module_path)
+
+    def __import_module(self, module_path: str):
+            """Importa um módulo Python a partir de um caminho de arquivo
+    
+            :param module_path: Caminho do arquivo do módulo
+            :returns: O módulo importado
+            :rtype: module
+            :raises ImportError: Se não for possível importar o módulo
+            """
+            try:
+                spec = importlib.util.spec_from_file_location("module_custom", module_path)
+                if spec is None or spec.loader is None:
+                    raise ImportError(f"Não foi possível criar o carregador do módulo '{module_path}'")
+
+                module = importlib.util.module_from_spec(spec)
+                with redirect_stdout(StringIO()), redirect_stderr(StringIO()):
+                    spec.loader.exec_module(module)
+                return module
+            except Exception as e:
+                self.logger.warning(f"Falha ao importar o módulo '{module_path}': {e}")
+                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 = False):
+        self.import_info = import_info
+        self.class_name = class_name
+        self.methods = methods
+        self.initialized = initialized
+        self.exists = self.check_existance()
+        self.instance = None
+
+    def check_existance(self):
+        """Testa se a classe existe e se possui os métodos esperados"""
+        cls = getattr(self.import_info.module, self.class_name, None)
+        if cls is None:
+            self.import_info.logger.warning(f"A classe '{self.class_name}' não foi encontrada no módulo.")
+            return False
+
+        for method in self.methods:
+            if not hasattr(cls, method["name"]):
+                self.import_info.logger.warning(f"O método '{method['name']}' não foi encontrado na classe '{self.class_name}'.")
+                return False
+
+        return True
+
+    def initialize_instance(self, *args) -> bool:
+        """Inicializa uma instância da classe com os argumentos fornecidos"""
+        if not self.exists:
+            self.import_info.logger.warning(f"A classe '{self.class_name}' não existe ou não possui os métodos esperados.")
+            return False
+
+        cls = getattr(self.import_info.module, self.class_name, None)
+        try:
+            self.instance = cls(*args)
+        except Exception as e:
+            self.import_info.logger.warning(f"Falha ao inicializar a instância da classe '{self.class_name}': {e}")
+            return False
+
+        return True
+
+    def get_existance(self):
+        """Retorna se a classe existe e possui os métodos esperados"""
+        return self.exists
+
+    def test_method(self, method_name: str, static: bool, input_args: list, expected_output):
+        """Testa se um método da classe retorna o valor esperado"""
+        if not self.exists:
+            self.import_info.logger.warning(f"A classe '{self.class_name}' não existe ou não possui os métodos esperados.")
+            return False
+
+        try:
+            cls = getattr(self.import_info.module, self.class_name, None)
+            method = getattr(cls, method_name, None)
+
+            if not static and self.instance is not None:
+                result, captured_stdout, _ = _call_with_captured_output(method, self.instance, *input_args)
+            else:
+                result, captured_stdout, _ = _call_with_captured_output(method, *input_args)
+
+            observed_output = result if result is not None else captured_stdout
+            if observed_output != expected_output and str(observed_output) != str(expected_output):
+                self.import_info.logger.warning(f"O método '{method_name}' retornou '{observed_output}', mas era esperado '{expected_output}'.")
+                return False
+        except Exception as e:
+            self.import_info.logger.warning(f"Falha ao testar o método '{method_name}': {e}")
+            self.import_info.logger.warning(f"Traceback: {traceback.format_exc()}")
+            return False
+
+        return True
+
+class FunctionTester:
+    def __init__(self, import_info: Imported, function_name: str):
+        self.import_info = import_info
+        self.function_name = function_name
+        self.exists = self.check_existance()
+
+    def check_existance(self):
+        """Testa se a função existe"""
+        func = getattr(self.import_info.module, self.function_name, None)
+        if func is None:
+            self.import_info.logger.warning(f"A função '{self.function_name}' não foi encontrada no módulo.")
+            return False
+
+        return True
+
+    def get_existance(self):
+        """Retorna se a função existe"""
+        return self.exists
+
+    def test(self, input_args: list, expected_output):
+        """Testa se a função retorna o valor esperado"""
+        if not self.exists:
+            self.import_info.logger.info(f"A função '{self.function_name}' não existe.")
+            return False
+
+        try:
+            func = getattr(self.import_info.module, self.function_name, None)
+            result, captured_stdout, _ = _call_with_captured_output(func, *input_args)
+            observed_output = result if result is not None else captured_stdout
+            if observed_output != expected_output and str(observed_output) != str(expected_output):
+                self.import_info.logger.warning(f"A função '{self.function_name}' retornou '{observed_output}', mas era esperado '{expected_output}'.")
+                return False
+        except Exception as e:
+            self.import_info.logger.warning(f"Falha ao testar a função '{self.function_name}': {e}")
+            self.import_info.logger.warning(f"Traceback: {traceback.format_exc()}")
+            return False
+
+        return True

verifica/tui.py

@@ -0,0 +1,102 @@
+from colorama import Style
+import re
+
+# Regex para remover 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 = []
+            words = text.split()
+            current_line = ""
+
+            for word in words:
+                if self.visible_len(f"{key}{Style.RESET_ALL} {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.dist-info/METADATA

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: verifica
+Version: 1.0.0
+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
+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
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: colorama>=0.4.6
+Requires-Dist: platformdirs>=2.5.2
+Dynamic: license-file
+
+<div align="center">
+    <h1 align="center">Verifica</h1>
+    <p align="center">Uma ferramenta simples para correção de atividades em python via CLI.<br>
+    <table>
+        <tbody>
+            <tr>
+                <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://github.com/espinafr/verifica/tree/master/docs">Como configurar</a></td>
+            </tr>
+        </tbody>
+    </table>
+</div>
+
+## Sobre o projeto
+
+**Verifica** é uma ferramenta simples que permite que professores preparem testes automatizados para corrigir atividades em python, fornecendo aos alunos uma correção instantânea para seus programas antes deles serem enviados oficialmente.
+
+## Como usar
+_Quer saber como criar os arquivos de correção? [Clique aqui](https://github.com/espinafr/verifica/tree/master/docs)_
+1. Baixe a ferramenta:
+```bash
+pip install verifica
+```
+
+2. Faça as atividades propostas com base nas orientações recebidas.
+
+3. No diretório com os arquivos `.py`, execute o comando `python -m verifica` seguido da localização do diretório com os arquivos de correção no github
+```bash
+python -m verifica usuario/repositorio/branch/localizacao/da/pasta
+```
+
+## Como compilar
+
+Para gerar os arquivos de distribuição do projeto, certifique-se de ter o módulo `build` instalado:
+
+```bash
+pip install build
+```
+
+Em seguida, execute o comando de construção na raiz do projeto:
+
+```bash
+python -m build
+```
+
+Os arquivos gerados (arquivos `.tar.gz` e `.whl`) estarão disponíveis no diretório `dist/`. Use o arquivo `.whl` para distribuição e instalação do pacote via pip.
+
+```bash
+pip install dist/{NOME DO ARQUIVO GERADO}
+```
+
+## Reconhecimentos
+
+Veja o arquivo [ACKNOWLEDGEMENTS](https://github.com/espinafr/verifica/blob/master/ACKNOWLEDGEMENTS.md).
+
+## Licença
+
+Veja o arquivo [LICENSE](https://github.com/espinafr/verifica/blob/master/LICENSE).

verifica-1.0.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+verifica/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+verifica/__main__.py,sha256=HTyOk5udinG7zqsDodcWyZAvQgmMcwkANx8DBUuDRnw,3329
+verifica/builder.py,sha256=QZgMASxalJxgS1wQw-_w_5ZuvuyY90vdMUuzwsndKN0,17917
+verifica/check.py,sha256=KkKBhCsZRXdjuu4Peoa6mga443pTw-LzorhNgCgxlp0,11715
+verifica/config.py,sha256=qVR6hUu4ErmOuBUv-pNAEtNzvjVzInOhzcmbWTRJj0g,2477
+verifica/fetcher.py,sha256=voSwYP2vh1O9epKrMOsCD3D8_gW53297AaWQlVH-x0o,2622
+verifica/imports_tester.py,sha256=ufVG695l7OWsjSMJ-t8thNiDnF1YAI-ootoIKDs9ieo,6489
+verifica/tui.py,sha256=h0PXZVB_YGvKXvw0QR0hILTvroxIESXCClvuCfrOklc,3917
+verifica-1.0.0.dist-info/licenses/LICENSE,sha256=2wrGlJpSJO5h3xtPNKsk-rRndHLvR3Gn-WpZjPv_eSI,1076
+verifica-1.0.0.dist-info/METADATA,sha256=d95CiZ-zwqzec27svCgR7EzxA82It7lpdjZkqrzhTOQ,2734
+verifica-1.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+verifica-1.0.0.dist-info/entry_points.txt,sha256=WRSI-L9wjQbngIA5Ib6vwaskkUFNuDGhhWxtuRhUEQQ,52
+verifica-1.0.0.dist-info/top_level.txt,sha256=ny1Gr7bCRgQGcTe8WfaEAZNUA1_BMhTRxc4cyF8V4Yo,9
+verifica-1.0.0.dist-info/RECORD,,

verifica-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

verifica-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+verifica = verifica.__main__:main

verifica-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Théo Modeneis Ruela
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

verifica-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+verifica