go1

app.py

@@ -1,207 +1,349 @@
-import gradio as gr
 import javalang
 from typing import Dict, List, Tuple
+from dataclasses import dataclass
+
+@dataclass
+class RubricCriterion:
+    name: str
+    description: str
+    weight: int
+    is_essential: bool
+    levels: Dict[str, Dict[str, float]]
+
+class EnhancedJavaPOOEvaluator:
+    """Avaliador POO com rubrica detalhada"""
 
-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,
+            "classes_objects": RubricCriterion(
+                name="Classes e Objetos",
+                description="Avalia a definição e uso de classes e objetos",
+                weight=20,
+                is_essential=True,
+                levels={
+                    "Fraco": {"threshold": 0, "description": "Nenhuma ou poucas classes/objetos"},
+                    "Regular": {"threshold": 10, "description": "Classes básicas sem organização clara"},
+                    "Bom": {"threshold": 15, "description": "Classes bem estruturadas e objetos adequados"},
+                    "Excelente": {"threshold": 20, "description": "Excelente uso de classes e objetos"}
+                }
+            ),
+            "methods": RubricCriterion(
+                name="Métodos",
+                description="Avalia métodos e sua organização",
+                weight=20,
+                is_essential=True,
+                levels={
+                    "Fraco": {"threshold": 0, "description": "Poucos métodos ou mal estruturados"},
+                    "Regular": {"threshold": 10, "description": "Métodos básicos sem sobrecarga"},
+                    "Bom": {"threshold": 15, "description": "Boa organização e alguns métodos sobrecarregados"},
+                    "Excelente": {"threshold": 20, "description": "Excelente organização e uso de sobrecarga"}
+                }
+            ),
+            "attributes": RubricCriterion(
+                name="Atributos",
+                description="Avalia atributos e sua organização",
+                weight=20,
+                is_essential=True,
+                levels={
+                    "Fraco": {"threshold": 0, "description": "Poucos atributos ou mal organizados"},
+                    "Regular": {"threshold": 10, "description": "Atributos básicos sem encapsulamento"},
+                    "Bom": {"threshold": 15, "description": "Boa organização de atributos"},
+                    "Excelente": {"threshold": 20, "description": "Excelente organização e encapsulamento"}
+                }
+            ),
+            "encapsulation": RubricCriterion(
+                name="Encapsulamento",
+                description="Avalia uso de modificadores e getters/setters",
+                weight=10,
+                is_essential=False,
+                levels={
+                    "Ausente": {"threshold": 0, "description": "Sem encapsulamento"},
+                    "Parcial": {"threshold": 5, "description": "Encapsulamento básico"},
+                    "Bom": {"threshold": 7.5, "description": "Bom uso de encapsulamento"},
+                    "Excelente": {"threshold": 10, "description": "Encapsulamento completo e correto"}
+                }
+            ),
+            "inheritance": RubricCriterion(
+                name="Herança",
+                description="Avalia uso de herança",
+                weight=10,
+                is_essential=False,
+                levels={
+                    "Ausente": {"threshold": 0, "description": "Sem uso de herança"},
+                    "Parcial": {"threshold": 5, "description": "Uso básico de herança"},
+                    "Bom": {"threshold": 7.5, "description": "Bom uso de herança"},
+                    "Excelente": {"threshold": 10, "description": "Uso avançado e apropriado de herança"}
+                }
+            ),
+            "polymorphism": RubricCriterion(
+                name="Polimorfismo",
+                description="Avalia uso de polimorfismo",
+                weight=10,
+                is_essential=False,
+                levels={
+                    "Ausente": {"threshold": 0, "description": "Sem uso de polimorfismo"},
+                    "Parcial": {"threshold": 5, "description": "Uso básico de sobrescrita"},
+                    "Bom": {"threshold": 7.5, "description": "Bom uso de polimorfismo"},
+                    "Excelente": {"threshold": 10, "description": "Uso avançado de polimorfismo"}
+                }
+            ),
+            "abstraction": RubricCriterion(
+                name="Abstração",
+                description="Avalia uso de abstrações",
+                weight=10,
+                is_essential=False,
+                levels={
+                    "Ausente": {"threshold": 0, "description": "Sem uso de abstração"},
+                    "Parcial": {"threshold": 5, "description": "Uso básico de interfaces/classes abstratas"},
+                    "Bom": {"threshold": 7.5, "description": "Bom uso de abstração"},
+                    "Excelente": {"threshold": 10, "description": "Uso completo de abstrações"}
+                }
+            )
         }
 
-    def analyze_classes_and_objects(self, code: str) -> Tuple[float, List[str]]:
-        """Avalia a definição e o uso de classes e objetos"""
+    def evaluate_criterion(self, criterion: RubricCriterion, analysis_result: Dict) -> Tuple[float, str, str]:
+        """Avalia um critério específico baseado nos resultados da análise"""
         score = 0
+        level = list(criterion.levels.keys())[0]  # Nível mais baixo por padrão
         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 = []
+        if criterion.name == "Classes e Objetos":
+            num_classes = len(analysis_result.get("classes", []))
+            num_objects = len(analysis_result.get("objects", []))
+
+            if num_classes >= 3 and num_objects >= 5:
+                score = criterion.weight
+                level = "Excelente"
+            elif num_classes >= 2 and num_objects >= 3:
+                score = criterion.weight * 0.75
+                level = "Bom"
+            elif num_classes >= 1 and num_objects >= 1:
+                score = criterion.weight * 0.5
+                level = "Regular"
+
+            feedback.append(f"Encontradas {num_classes} classes e {num_objects} objetos")
+
+        elif criterion.name == "Métodos":
+            methods = analysis_result.get("methods", [])
+            method_names = [m.name for m in methods]
+            overloaded = len([name for name in method_names if method_names.count(name) > 1])
+
+            if len(methods) >= 5 and overloaded >= 2:
+                score = criterion.weight
+                level = "Excelente"
+            elif len(methods) >= 3 and overloaded >= 1:
+                score = criterion.weight * 0.75
+                level = "Bom"
+            elif len(methods) >= 1:
+                score = criterion.weight * 0.5
+                level = "Regular"
+
+            feedback.append(f"Encontrados {len(methods)} métodos, sendo {overloaded} sobrecarregados")
+
+        elif criterion.name == "Atributos":
+            attributes = analysis_result.get("attributes", [])
+            num_private = analysis_result["encapsulation"]["private_count"]
+
+            if len(attributes) >= 5 and num_private >= 3:
+                score = criterion.weight
+                level = "Excelente"
+            elif len(attributes) >= 3 and num_private >= 1:
+                score = criterion.weight * 0.75
+                level = "Bom"
+            elif len(attributes) >= 1:
+                score = criterion.weight * 0.5
+                level = "Regular"
+
+            feedback.append(f"Encontrados {len(attributes)} atributos, sendo {num_private} privados")
+
+        elif criterion.name == "Encapsulamento":
+            num_private = analysis_result["encapsulation"]["private_count"]
+            num_getters_setters = analysis_result["encapsulation"]["getters_setters"]
+
+            if num_private >= 3 and num_getters_setters >= 4:
+                score = criterion.weight
+                level = "Excelente"
+            elif num_private >= 2 and num_getters_setters >= 3:
+                score = criterion.weight * 0.75
+                level = "Bom"
+            elif num_private >= 1 and num_getters_setters >= 2:
+                score = criterion.weight * 0.5
+                level = "Parcial"
+
+            feedback.append(f"Encontrados {num_private} atributos privados e {num_getters_setters} getters/setters")
+
+        elif criterion.name == "Herança":
+            subclasses = analysis_result["inheritance"]["subclasses"]
+
+            if len(subclasses) >= 3:
+                score = criterion.weight
+                level = "Excelente"
+            elif len(subclasses) >= 2:
+                score = criterion.weight * 0.75
+                level = "Bom"
+            elif len(subclasses) >= 1:
+                score = criterion.weight * 0.5
+                level = "Parcial"
+
+            feedback.append(f"Encontradas {len(subclasses)} classes que usam herança")
+
+        elif criterion.name == "Polimorfismo":
+            overridden = len(analysis_result["polymorphism"]["overridden_methods"])
+
+            if overridden >= 3:
+                score = criterion.weight
+                level = "Excelente"
+            elif overridden >= 2:
+                score = criterion.weight * 0.75
+                level = "Bom"
+            elif overridden >= 1:
+                score = criterion.weight * 0.5
+                level = "Parcial"
+
+            feedback.append(f"Encontrados {overridden} métodos sobrescritos")
+
+        elif criterion.name == "Abstração":
+            abstract_classes = len(analysis_result["abstraction"]["abstract_classes"])
+            interfaces = len(analysis_result["abstraction"]["interfaces"])
+
+            if abstract_classes >= 1 and interfaces >= 1:
+                score = criterion.weight
+                level = "Excelente"
+            elif abstract_classes >= 1 and interfaces >= 0:
+                score = criterion.weight * 0.75
+                level = "Bom"
+            elif abstract_classes >= 1 or interfaces >= 1:
+                score = criterion.weight * 0.5
+                level = "Parcial"
+
+            feedback.append(f"Encontradas {abstract_classes} classes abstratas e {interfaces} interfaces")
+
+        return score, level, ". ".join(feedback)
+
+    def analyze_code(self, code: str) -> Dict:
+        """Analisa o código Java e retorna dados brutos"""
+        analysis = {
+            "classes": [],
+            "objects": [],
+            "methods": [],
+            "attributes": [],
+            "encapsulation": {"private_count": 0, "getters_setters": 0},
+            "inheritance": {"subclasses": []},
+            "polymorphism": {"overridden_methods": []},
+            "abstraction": {"abstract_classes": [], "interfaces": []}
+        }
 
         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
+            # Análise de classes e objetos
+            analysis["classes"] = [node for _, node in tree.filter(javalang.tree.ClassDeclaration)]
+            analysis["objects"] = [node for _, node in tree.filter(javalang.tree.VariableDeclarator)
+                                 if isinstance(node.initializer, javalang.tree.ClassCreator)]
 
-    def analyze_encapsulation(self, code: str) -> Tuple[float, List[str]]:
-        """Avalia encapsulamento e uso de modificadores"""
-        score = 0
-        feedback = []
+            # Análise de métodos
+            analysis["methods"] = [node for _, node in tree.filter(javalang.tree.MethodDeclaration)]
 
-        try:
-            tree = javalang.parse.parse(code)
-            fields = list(tree.filter(javalang.tree.FieldDeclaration))
+            # Análise de atributos e encapsulamento
+            fields = [node for _, node in tree.filter(javalang.tree.FieldDeclaration)]
+            analysis["attributes"] = fields
+            analysis["encapsulation"]["private_count"] = sum(1 for field in fields
+                                                           if "private" in field.modifiers)
 
-            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'.")
+            # Contagem de getters e setters
+            methods = analysis["methods"]
+            getters_setters = sum(1 for method in methods
+                                if method.name.startswith('get') or method.name.startswith('set'))
+            analysis["encapsulation"]["getters_setters"] = getters_setters
 
-            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.")
+            # Análise de herança
+            analysis["inheritance"]["subclasses"] = [cls for cls in analysis["classes"]
+                                                   if cls.extends is not None]
 
-        return score, feedback
+            # Análise de polimorfismo
+            analysis["polymorphism"]["overridden_methods"] = [method for method in methods
+                                                            if any(ann.name == "Override"
+                                                                  for ann in (method.annotations or []))]
 
-    def analyze_inheritance(self, code: str) -> Tuple[float, List[str]]:
-        """Avalia o uso de herança"""
-        score = 0
-        feedback = []
+            # Análise de abstração
+            analysis["abstraction"]["abstract_classes"] = [cls for cls in analysis["classes"]
+                                                         if "abstract" in cls.modifiers]
+            analysis["abstraction"]["interfaces"] = [node for _, node in tree.filter(javalang.tree.InterfaceDeclaration)]
 
-        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.")
+            print(f"Erro na análise: {str(e)}")
 
-        return score, feedback
+        return analysis
 
-    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.")
+    def evaluate_code(self, code: str) -> Dict:
+        """Avalia o código Java usando a rubrica detalhada"""
+        analysis = self.analyze_code(code)
+        evaluation = {
+            "scores": {},
+            "levels": {},
+            "feedback": {},
+            "summary": {
+                "essential_score": 0,
+                "bonus_score": 0,
+                "total_score": 0
+            }
+        }
 
-        return score, feedback
+        # Avalia cada critério
+        for criterion_key, criterion in self.rubric.items():
+            score, level, feedback = self.evaluate_criterion(criterion, analysis)
 
-    def analyze_abstraction(self, code: str) -> Tuple[float, List[str]]:
-        """Avalia o uso de abstração"""
-        score = 0
-        feedback = []
+            evaluation["scores"][criterion_key] = score
+            evaluation["levels"][criterion_key] = level
+            evaluation["feedback"][criterion_key] = 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).")
+            if criterion.is_essential:
+                evaluation["summary"]["essential_score"] += score
             else:
-                feedback.append("⚠ Nenhuma classe abstrata encontrada.")
+                evaluation["summary"]["bonus_score"] += score
 
-            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.")
+        evaluation["summary"]["total_score"] = min(100,
+            evaluation["summary"]["essential_score"] +
+            evaluation["summary"]["bonus_score"])
 
-        return score, feedback
+        # Determina nível geral
+        if evaluation["summary"]["total_score"] >= 90:
+            evaluation["summary"]["proficiency"] = "Excelente"
+        elif evaluation["summary"]["total_score"] >= 75:
+            evaluation["summary"]["proficiency"] = "Bom"
+        elif evaluation["summary"]["total_score"] >= 60:
+            evaluation["summary"]["proficiency"] = "Satisfatório"
+        else:
+            evaluation["summary"]["proficiency"] = "Necessita Melhorias"
 
-    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,
-            }
-        }
+        return evaluation
 
 # Interface Gradio
-with gr.Blocks(title="Java-Judge: OO Paradigm", css="#rubric_image img {max-width: 50%; height: auto; margin: 0 auto;}") as demo:
+with gr.Blocks(title="Avaliador de POO em Java") 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")
-    
+    gr.Markdown("""
+    Este avaliador analisa código Java em relação aos princípios de Programação Orientada a Objetos.
+
+    Critérios avaliados:
+   
+    """)
+    # Links usando caminho completo do Hugging Face
+    gr.HTML(f"""
+    <h3>
+        <a href="https://huggingface.co/spaces/rmayormartins/java-judge-oo/resolve/main/assets/rubric.pdf" target="_blank">📄 Visualizar Rubrica PDF</a>
+    </h3>
+    <h3>
+        <a href="https://huggingface.co/spaces/rmayormartins/java-judge-oo/resolve/main/assets/rubric_table.PNG" target="_blank">📊 Visualizar Tabela da Rubrica</a>
+    </h3>
+    """)
+
     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()
+        """Função para avaliar múltiplos arquivos Java"""
+        evaluator = EnhancedJavaPOOEvaluator()
         results = []
 
         for file in files:
@@ -209,14 +351,27 @@ with gr.Blocks(title="Java-Judge: OO Paradigm", css="#rubric_image img {max-widt
                 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"
+            # Formatar resultado por arquivo
+            result = f"\n{'='*50}\nAvaliação do arquivo: {file.name}\n{'='*50}\n\n"
+
+            # Pontuação e nível geral
+            result += f"Pontuação Total: {evaluation['summary']['total_score']:.1f}/100\n"
+            result += f"Nível de Proficiência: {evaluation['summary']['proficiency']}\n"
+            result += f"Pontuação Essencial: {evaluation['summary']['essential_score']:.1f}/60\n"
+            result += f"Pontuação Bônus: {evaluation['summary']['bonus_score']:.1f}/40\n\n"
+
+            # Detalhamento por critério
+            result += "Avaliação Detalhada por Critério:\n"
+            result += "-" * 30 + "\n\n"
+
+            for criterion_key, criterion in evaluator.rubric.items():
+                result += f"• {criterion.name}:\n"
+                result += f"  Nível: {evaluation['levels'][criterion_key]}\n"
+                result += f"  Pontuação: {evaluation['scores'][criterion_key]:.1f}/{criterion.weight}\n"
+                if evaluation['feedback'][criterion_key]:
+                    result += f"  Feedback: {evaluation['feedback'][criterion_key]}\n"
+                result += "\n"
+
             results.append(result)
 
         return "\n".join(results)
@@ -224,4 +379,4 @@ with gr.Blocks(title="Java-Judge: OO Paradigm", css="#rubric_image img {max-widt
     evaluate_button.click(fn=evaluate_code_files, inputs=upload, outputs=output)
 
 if __name__ == "__main__":
-    demo.launch(share=True)
+    demo.launch(debug=True)