verifica 1.0.0.dev1__tar.gz

verifica-1.0.0.dev1/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.dev1/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: verifica
+Version: 1.0.0.dev1
+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.13
+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.</p>
+</div>
+
+## Sobre o projeto
+
+**Verifica** é uma ferramenta simples que permite que professores preparem testes automatizados para corrigir suas ativiaddes em python, fornecendo aos alunos uma correção instantânea para seus programas antes deles serem enviados.
+
+## 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}
+```
+
+## Licença
+
+Veja o arquivo LICENSE.

verifica-1.0.0.dev1/README.md

@@ -0,0 +1,32 @@
+<div align="center">
+    <h1 align="center">Verifica</h1>
+    <p align="center">Uma ferramenta simples para correção de atividades em python via CLI.</p>
+</div>
+
+## Sobre o projeto
+
+**Verifica** é uma ferramenta simples que permite que professores preparem testes automatizados para corrigir suas ativiaddes em python, fornecendo aos alunos uma correção instantânea para seus programas antes deles serem enviados.
+
+## 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}
+```
+
+## Licença
+
+Veja o arquivo LICENSE.

verifica-1.0.0.dev1/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools >= 77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "verifica"
+version = "1.0.0.dev1"
+dependencies = [
+    "colorama>=0.4.6",
+    "platformdirs>=2.5.2"
+]
+authors = [
+  { name="Théo Modeneis Ruela", email="theo.ruela@gmail.com" },
+]
+description = "Uma ferramenta simples para correção de atividades em python via CLI."
+readme = "README.md"
+requires-python = ">=3.9.13"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+[project.urls]
+Homepage = "https://github.com/espinafr/Verifica"
+Issues = "https://github.com/espinafr/Verifica/issues"
+
+[project.scripts]
+verifica = "verifica.__main__:main"

verifica-1.0.0.dev1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

verifica-1.0.0.dev1/src/verifica/__main__.py

@@ -0,0 +1,71 @@
+import argparse
+from pathlib import Path
+import logging
+import sys
+
+from .config import settings
+from .check import Checker
+from .fetcher import Fetcher
+
+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)]
+)
+
+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 usada 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.")
+    
+    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 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-1.0.0.dev1/src/verifica/check.py

@@ -0,0 +1,219 @@
+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
+from .config import settings
+
+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)
+                                currentClass = imports_tester.ClassTester(importedFile, class_info["name"], class_info["methods"], 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"]["args"]],
+                                        "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 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 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 ""
+        }
+        return f"{colors[result]}{colors['bold']}{':)' if result else ':('}{colors['reset']} {colors[result]}{info}{colors['reset']}"
+
+    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-1.0.0.dev1/src/verifica/config.py

@@ -0,0 +1,88 @@
+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
+
+    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
+        self.enviroment_supports_colors = setup_colors()
+
+        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):
+        try:
+            current_version = version("verifica")
+        except PackageNotFoundError:
+            current_version = f"indev-{time()}"
+
+        defaultConfig = {
+            "version": current_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 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-1.0.0.dev1/src/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-1.0.0.dev1/src/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):
+        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-1.0.0.dev1/src/verifica.egg-info/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: verifica
+Version: 1.0.0.dev1
+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.13
+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.</p>
+</div>
+
+## Sobre o projeto
+
+**Verifica** é uma ferramenta simples que permite que professores preparem testes automatizados para corrigir suas ativiaddes em python, fornecendo aos alunos uma correção instantânea para seus programas antes deles serem enviados.
+
+## 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}
+```
+
+## Licença
+
+Veja o arquivo LICENSE.

verifica-1.0.0.dev1/src/verifica.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+src/verifica/__init__.py
+src/verifica/__main__.py
+src/verifica/check.py
+src/verifica/config.py
+src/verifica/fetcher.py
+src/verifica/imports_tester.py
+src/verifica.egg-info/PKG-INFO
+src/verifica.egg-info/SOURCES.txt
+src/verifica.egg-info/dependency_links.txt
+src/verifica.egg-info/entry_points.txt
+src/verifica.egg-info/requires.txt
+src/verifica.egg-info/top_level.txt

verifica-1.0.0.dev1/src/verifica.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

verifica-1.0.0.dev1/src/verifica.egg-info/entry_points.txt

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

verifica-1.0.0.dev1/src/verifica.egg-info/requires.txt

@@ -0,0 +1,2 @@
+colorama>=0.4.6
+platformdirs>=2.5.2

verifica-1.0.0.dev1/src/verifica.egg-info/top_level.txt

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