Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| import javalang | |
| from typing import Dict, List, Tuple | |
| class JavaPOOEvaluator: | |
| """Java-Judge: OO Paradigm""" | |
| def __init__(self): | |
| self.rubric = { | |
| "classes": 20, | |
| "objetos": 20, | |
| "metodos": 20, | |
| "atributos": 20, | |
| "encapsulamento": 10, | |
| "heranca": 10, | |
| "polimorfismo": 10, | |
| "abstracao": 10, | |
| } | |
| def analyze_classes_and_objects(self, code: str) -> Tuple[float, List[str]]: | |
| """Avalia a definição e o uso de classes e objetos""" | |
| score = 0 | |
| feedback = [] | |
| try: | |
| tree = javalang.parse.parse(code) | |
| classes = list(tree.filter(javalang.tree.ClassDeclaration)) | |
| if classes: | |
| score += 15 | |
| feedback.append(f"✓ {len(classes)} classe(s) declarada(s) corretamente.") | |
| else: | |
| feedback.append("⚠ Nenhuma classe declarada encontrada.") | |
| objects = [node for _, node in tree.filter(javalang.tree.VariableDeclarator) if 'new' in str(node.initializer)] | |
| if objects: | |
| score += 5 | |
| feedback.append(f"✓ {len(objects)} objeto(s) criado(s) corretamente.") | |
| else: | |
| feedback.append("⚠ Nenhuma instância de objeto criada.") | |
| except Exception as e: | |
| feedback.append("⚠ Erro ao analisar classes e objetos.") | |
| return score, feedback | |
| def analyze_methods(self, code: str) -> Tuple[float, List[str]]: | |
| """Avalia a definição e organização de métodos""" | |
| score = 0 | |
| feedback = [] | |
| try: | |
| tree = javalang.parse.parse(code) | |
| methods = list(tree.filter(javalang.tree.MethodDeclaration)) | |
| if methods: | |
| score += 15 | |
| feedback.append(f"✓ {len(methods)} método(s) declarado(s) corretamente.") | |
| else: | |
| feedback.append("⚠ Nenhum método declarado encontrado.") | |
| except Exception as e: | |
| feedback.append(f"⚠ Erro ao analisar métodos: {e}") | |
| return score, feedback | |
| def analyze_encapsulation(self, code: str) -> Tuple[float, List[str]]: | |
| """Avalia encapsulamento e uso de modificadores""" | |
| score = 0 | |
| feedback = [] | |
| try: | |
| tree = javalang.parse.parse(code) | |
| fields = list(tree.filter(javalang.tree.FieldDeclaration)) | |
| private_count = sum(1 for _, node in fields if 'private' in node.modifiers) | |
| if private_count: | |
| score += 5 | |
| feedback.append(f"✓ {private_count} atributo(s) encapsulado(s) com 'private'.") | |
| getters_setters = [method for _, method in tree.filter(javalang.tree.MethodDeclaration) if method.name.startswith('get') or method.name.startswith('set')] | |
| if getters_setters: | |
| score += 5 | |
| feedback.append(f"✓ {len(getters_setters)} getter(s) ou setter(s) implementado(s).") | |
| else: | |
| feedback.append("⚠ Nenhum getter ou setter encontrado.") | |
| except Exception as e: | |
| feedback.append("⚠ Erro ao analisar encapsulamento.") | |
| return score, feedback | |
| def analyze_inheritance(self, code: str) -> Tuple[float, List[str]]: | |
| """Avalia o uso de herança""" | |
| score = 0 | |
| feedback = [] | |
| try: | |
| tree = javalang.parse.parse(code) | |
| subclasses = [node for _, node in tree.filter(javalang.tree.ClassDeclaration) if node.extends] | |
| if subclasses: | |
| score += 10 | |
| feedback.append(f"✓ {len(subclasses)} classe(s) estendendo outra(s).") | |
| else: | |
| feedback.append("⚠ Nenhum uso de herança encontrado.") | |
| except Exception as e: | |
| feedback.append("⚠ Erro ao analisar herança.") | |
| return score, feedback | |
| def analyze_polymorphism(self, code: str) -> Tuple[float, List[str]]: | |
| """Avalia o uso de polimorfismo""" | |
| score = 0 | |
| feedback = [] | |
| try: | |
| tree = javalang.parse.parse(code) | |
| overridden_methods = [node for _, node in tree.filter(javalang.tree.MethodDeclaration) if 'Override' in (node.annotations or [])] | |
| if overridden_methods: | |
| score += 10 | |
| feedback.append(f"✓ {len(overridden_methods)} método(s) sobrescrito(s) corretamente.") | |
| else: | |
| feedback.append("⚠ Nenhum uso de polimorfismo encontrado.") | |
| except Exception as e: | |
| feedback.append("⚠ Erro ao analisar polimorfismo.") | |
| return score, feedback | |
| def analyze_abstraction(self, code: str) -> Tuple[float, List[str]]: | |
| """Avalia o uso de abstração""" | |
| score = 0 | |
| feedback = [] | |
| try: | |
| tree = javalang.parse.parse(code) | |
| abstract_classes = [node for _, node in tree.filter(javalang.tree.ClassDeclaration) if 'abstract' in node.modifiers] | |
| interfaces = list(tree.filter(javalang.tree.InterfaceDeclaration)) | |
| if abstract_classes: | |
| score += 5 | |
| feedback.append(f"✓ {len(abstract_classes)} classe(s) abstrata(s) declarada(s).") | |
| else: | |
| feedback.append("⚠ Nenhuma classe abstrata encontrada.") | |
| if interfaces: | |
| score += 5 | |
| feedback.append(f"✓ {len(interfaces)} interface(s) declarada(s).") | |
| else: | |
| feedback.append("⚠ Nenhuma interface encontrada.") | |
| except Exception as e: | |
| feedback.append("⚠ Erro ao analisar abstração.") | |
| return score, feedback | |
| def evaluate_code(self, code: str) -> Dict: | |
| """Avalia o código Java""" | |
| cls_score, cls_feedback = self.analyze_classes_and_objects(code) | |
| meth_score, meth_feedback = self.analyze_methods(code) | |
| enc_score, enc_feedback = self.analyze_encapsulation(code) | |
| inh_score, inh_feedback = self.analyze_inheritance(code) | |
| poly_score, poly_feedback = self.analyze_polymorphism(code) | |
| abs_score, abs_feedback = self.analyze_abstraction(code) | |
| essential_score = cls_score + meth_score | |
| bonus_score = enc_score + inh_score + poly_score + abs_score | |
| total_score = essential_score + bonus_score | |
| total_score = min(100, total_score) | |
| proficiency = "Necessita Melhorias" | |
| if total_score >= 90: | |
| proficiency = "Excelente" | |
| elif total_score >= 75: | |
| proficiency = "Bom" | |
| elif total_score >= 60: | |
| proficiency = "Satisfatório" | |
| return { | |
| "total_score": total_score, | |
| "essential_score": essential_score, | |
| "bonus_score": bonus_score, | |
| "proficiency": proficiency, | |
| "feedback": { | |
| "classes_objetos": cls_feedback, | |
| "metodos": meth_feedback, | |
| "encapsulamento": enc_feedback, | |
| "heranca": inh_feedback, | |
| "polimorfismo": poly_feedback, | |
| "abstracao": abs_feedback, | |
| } | |
| } | |
| # Interface Gradio | |
| with gr.Blocks(title="Java-Judge: OO Paradigm", css="#rubric_image img {max-width: 50%; height: auto; margin: 0 auto;}") as demo: | |
| gr.Markdown("# Avaliador de POO em Java") | |
| gr.Markdown("### [Visualizar a Rubrica em PDF](rubric.pdf)") | |
| gr.Markdown("#### Avalie seu código Java com base em critérios de POO") | |
| upload = gr.File(label="Carregue arquivos Java para avaliação", file_types=[".java"], file_count="multiple") | |
| evaluate_button = gr.Button("Avaliar Código") | |
| output = gr.Textbox(label="Resultado da Avaliação", lines=25) | |
| gr.Markdown("### Rubrica de Avaliação") | |
| rubric_image = gr.Image("rubric_table.png", label="Tabela Resumida da Rubrica", elem_id="rubric_image") | |
| def evaluate_code_files(files) -> str: | |
| evaluator = JavaPOOEvaluator() | |
| results = [] | |
| for file in files: | |
| with open(file.name, 'r', encoding='utf-8') as f: | |
| code = f.read() | |
| evaluation = evaluator.evaluate_code(code) | |
| result = f"\nArquivo: {file.name}\n" | |
| result += f"Pontuação Total: {evaluation['total_score']:.1f}/100\n" | |
| result += f"Nível: {evaluation['proficiency']}\n\n" | |
| result += "Feedback Detalhado:\n" | |
| for category, comments in evaluation['feedback'].items(): | |
| result += f"\n{category.replace('_', ' ').title()}:\n" | |
| for comment in comments: | |
| result += f" {comment}\n" | |
| results.append(result) | |
| return "\n".join(results) | |
| evaluate_button.click(fn=evaluate_code_files, inputs=upload, outputs=output) | |
| if __name__ == "__main__": | |
| demo.launch(share=True) | |