Update app.py

app.py

@@ -831,4 +831,342 @@ class RequirementsAnalysisModule:
         for i, req in enumerate(requirements):
             related = []
             
-            for j
+            for j, similarity in enumerate(similarity_matrix[i]):
+                if i != j and similarity > 0.3:  # Threshold for relationship
+                    related.append({
+                        "id": requirements[j]["id"],
+                        "similarity": float(similarity),
+                        "relationship_type": self._determine_relationship_type(req, requirements[j])
+                    })
+            
+            # Sort by similarity
+            related.sort(key=lambda x: x["similarity"], reverse=True)
+            
+            # Add to requirement
+            req["related_requirements"] = related[:5]  # Top 5 related requirements
+    
+    def _determine_relationship_type(self, req1: Dict, req2: Dict) -> str:
+        """
+        Determine the type of relationship between two requirements.
+        
+        Args:
+            req1: First requirement
+            req2: Second requirement
+            
+        Returns:
+            Relationship type string
+        """
+        # Check for system relationships
+        systems1 = set(req1["extracted"]["systems"])
+        systems2 = set(req2["extracted"]["systems"])
+        
+        if systems1.intersection(systems2):
+            return "same_system"
+        
+        # Check for business domain relationships
+        domains1 = [d[0] for d in req1["extracted"]["business_domain"]]
+        domains2 = [d[0] for d in req2["extracted"]["business_domain"]]
+        
+        if set(domains1).intersection(set(domains2)):
+            return "same_domain"
+        
+        # Check for action relationships
+        actions1 = set(req1["extracted"]["actions"])
+        actions2 = set(req2["extracted"]["actions"])
+        
+        if actions1.intersection(actions2):
+            return "similar_action"
+            
+        # Default relationship type
+        return "related"
+    
+    def map_requirements_to_processes(self, requirements: List[Dict], process_models: List[Dict]) -> Dict:
+        """
+        Map requirements to process models based on content matching.
+        
+        Args:
+            requirements: List of analyzed requirements
+            process_models: List of process model dictionaries
+            
+        Returns:
+            Dictionary mapping process IDs to requirement IDs
+        """
+        process_to_reqs = {}
+        req_to_process = {}
+        
+        for process in process_models:
+            process_id = process.get("id", "unknown")
+            process_text = process.get("description", "") + " " + process.get("name", "")
+            process_doc = self.nlp(process_text)
+            
+            # Find matching requirements
+            matching_reqs = []
+            
+            for req in requirements:
+                req_text = req["text"]
+                req_doc = self.nlp(req_text)
+                
+                # Calculate similarity
+                similarity = process_doc.similarity(req_doc)
+                
+                if similarity > 0.6:  # Threshold for matching
+                    matching_reqs.append({
+                        "req_id": req["id"],
+                        "similarity": float(similarity)
+                    })
+                    req_to_process[req["id"]] = process_id
+            
+            # Sort by similarity
+            matching_reqs.sort(key=lambda x: x["similarity"], reverse=True)
+            process_to_reqs[process_id] = matching_reqs
+        
+        return {
+            "process_to_requirements": process_to_reqs,
+            "requirement_to_process": req_to_process
+        }
+    
+    def evaluate_automation_potential(self, requirement: Dict) -> Dict:
+        """
+        Evaluate the automation potential of a requirement.
+        
+        Args:
+            requirement: Analyzed requirement
+            
+        Returns:
+            Automation potential assessment
+        """
+        # Basic score starts at 5 out of 10
+        score = 5
+        
+        # Complexity factor (high complexity decreases score)
+        complexity = requirement["extracted"]["complexity"]
+        if complexity == "high":
+            score -= 2
+        elif complexity == "low":
+            score += 2
+        
+        # Action factor (certain actions are more automatable)
+        automatable_actions = ["extract", "transfer", "copy", "move", "calculate", 
+                              "update", "generate", "validate", "verify", "send",
+                              "notify", "schedule", "retrieve", "check"]
+        
+        for action in requirement["extracted"]["actions"]:
+            if action in automatable_actions:
+                score += 0.5
+                
+        # System factor (presence of systems increases score)
+        if requirement["extracted"]["systems"]:
+            score += len(requirement["extracted"]["systems"]) * 0.5
+            
+        # Data elements factor (more data elements suggests more structure)
+        data_elements = requirement["extracted"]["data_elements"]
+        if data_elements:
+            score += min(len(data_elements) * 0.3, 2)  # Cap at +2
+            
+        # Cap score between 1-10
+        score = max(1, min(10, score))
+        
+        # Determine category
+        category = "high" if score >= 7.5 else "medium" if score >= 5 else "low"
+        
+        # Identify automation technology
+        tech = self._recommend_automation_technology(requirement, score)
+        
+        return {
+            "automation_score": round(score, 1),
+            "automation_category": category,
+            "recommended_technology": tech,
+            "rationale": self._generate_automation_rationale(requirement, score, category)
+        }
+    
+    def _recommend_automation_technology(self, requirement: Dict, score: float) -> str:
+        """
+        Recommend suitable automation technology.
+        
+        Args:
+            requirement: Analyzed requirement
+            score: Automation score
+            
+        Returns:
+            Recommended technology
+        """
+        complexity = requirement["extracted"]["complexity"]
+        actions = requirement["extracted"]["actions"]
+        
+        # Decision tree for technology recommendation
+        if score >= 8:
+            if any(a in actions for a in ["extract", "scrape", "read"]):
+                return "RPA with OCR/Document Understanding"
+            else:
+                return "Traditional RPA"
+        elif score >= 5:
+            if complexity == "high":
+                return "RPA with Human-in-the-Loop"
+            elif any(a in actions for a in ["decide", "evaluate", "assess"]):
+                return "RPA with Decision Automation"
+            else:
+                return "Traditional RPA"
+        else:
+            if any(a in actions for a in ["review", "approve"]):
+                return "Workflow Automation"
+            else:
+                return "Partial Automation with Human Tasks"
+    
+    def _generate_automation_rationale(self, requirement: Dict, score: float, category: str) -> str:
+        """
+        Generate explanation for automation assessment.
+        
+        Args:
+            requirement: Analyzed requirement
+            score: Automation score
+            category: Automation category
+            
+        Returns:
+            Rationale text
+        """
+        complexity = requirement["extracted"]["complexity"]
+        
+        if category == "high":
+            return (f"This requirement has {complexity} complexity but shows strong automation "
+                   f"potential due to clear structure and defined data elements. "
+                   f"Score of {score}/10 indicates this is a prime automation candidate.")
+        elif category == "medium":
+            return (f"This {complexity} complexity requirement has moderate automation potential. "
+                   f"Score of {score}/10 suggests partial automation with some human oversight.")
+        else:
+            return (f"The {complexity} complexity and ambiguous nature of this requirement "
+                   f"limits automation potential. Score of {score}/10 indicates this may "
+                   f"require significant human involvement or process redesign.")
+    
+    def assess_requirements_automation_potential(self, requirements: List[Dict]) -> List[Dict]:
+        """
+        Assess automation potential for a batch of requirements.
+        
+        Args:
+            requirements: List of analyzed requirements
+            
+        Returns:
+            Requirements with automation assessment added
+        """
+        for req in requirements:
+            req["automation_potential"] = self.evaluate_automation_potential(req)
+            
+        return requirements
+    
+    def generate_requirements_report(self, requirements: List[Dict]) -> Dict:
+        """
+        Generate a summary report of requirements analysis.
+        
+        Args:
+            requirements: List of analyzed requirements
+            
+        Returns:
+            Report dictionary
+        """
+        # Count by complexity
+        complexity_counts = {"high": 0, "medium": 0, "low": 0}
+        for req in requirements:
+            complexity = req["extracted"]["complexity"]
+            complexity_counts[complexity] += 1
+            
+        # Count by automation potential
+        if all("automation_potential" in req for req in requirements):
+            automation_counts = {"high": 0, "medium": 0, "low": 0}
+            for req in requirements:
+                category = req["automation_potential"]["automation_category"]
+                automation_counts[category] += 1
+        else:
+            automation_counts = None
+            
+        # Find common systems
+        all_systems = []
+        for req in requirements:
+            all_systems.extend(req["extracted"]["systems"])
+            
+        system_counts = {}
+        for system in all_systems:
+            if system in system_counts:
+                system_counts[system] += 1
+            else:
+                system_counts[system] = 1
+                
+        # Sort systems by frequency
+        top_systems = sorted(system_counts.items(), key=lambda x: x[1], reverse=True)[:5]
+        
+        # Generate report
+        report = {
+            "total_requirements": len(requirements),
+            "complexity_distribution": complexity_counts,
+            "automation_potential": automation_counts,
+            "top_systems": top_systems,
+            "recommendations": self._generate_overall_recommendations(requirements)
+        }
+        
+        return report
+    
+    def _generate_overall_recommendations(self, requirements: List[Dict]) -> List[str]:
+        """
+        Generate overall recommendations based on requirements analysis.
+        
+        Args:
+            requirements: List of analyzed requirements
+            
+        Returns:
+            List of recommendation strings
+        """
+        recommendations = []
+        
+        # Check if automation assessment is available
+        automation_available = all("automation_potential" in req for req in requirements)
+        
+        if automation_available:
+            # Count high automation potential requirements
+            high_potential = [r for r in requirements 
+                             if r["automation_potential"]["automation_category"] == "high"]
+            
+            if len(high_potential) >= len(requirements) * 0.7:
+                recommendations.append(
+                    "High automation potential across most requirements. "
+                    "Consider an end-to-end automation solution."
+                )
+            elif len(high_potential) >= len(requirements) * 0.3:
+                recommendations.append(
+                    "Significant automation potential in a subset of requirements. "
+                    "Consider a phased automation approach starting with high-potential areas."
+                )
+            else:
+                recommendations.append(
+                    "Limited automation potential in current requirements. "
+                    "Consider process redesign to increase automation potential."
+                )
+                
+            # Recommend technologies
+            tech_counts = {}
+            for req in requirements:
+                tech = req["automation_potential"]["recommended_technology"]
+                tech_counts[tech] = tech_counts.get(tech, 0) + 1
+                
+            top_tech = max(tech_counts.items(), key=lambda x: x[1])[0]
+            recommendations.append(f"Primary recommended technology: {top_tech}")
+        
+        # Requirements quality recommendations
+        completeness_issues = False
+        for req in requirements:
+            if (not req["extracted"]["actions"] or 
+                not req["extracted"]["systems"] or 
+                not req["extracted"]["data_elements"]):
+                completeness_issues = True
+                break
+                
+        if completeness_issues:
+            recommendations.append(
+                "Some requirements lack necessary details. "
+                "Consider refining requirements to specify actions, systems, and data elements."
+            )
+            
+        return recommendations
+
+Version 2 of 2
+
+
+