Upload folder using huggingface_hub

reasoning/venture_strategies.py

@@ -421,3 +421,158 @@ class VenturePortfolioStrategy(ReasoningStrategy):
                 "burn_rate": sum(v.metrics.burn_rate for v in self.ventures)
             }
         }
+
+class VentureStrategy(ReasoningStrategy):
+    """
+    Advanced venture strategy that combines multiple specialized strategies
+    to generate comprehensive business plans and recommendations.
+    """
+    
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        """Initialize venture strategy with component strategies."""
+        super().__init__()
+        self.config = config or {}
+        
+        # Initialize component strategies
+        self.strategies = {
+            VentureType.AI_STARTUP: AIStartupStrategy(),
+            VentureType.SAAS: SaaSVentureStrategy(),
+            VentureType.AUTOMATION_SERVICE: AutomationVentureStrategy(),
+            VentureType.DATA_ANALYTICS: DataVentureStrategy(),
+            VentureType.API_SERVICE: APIVentureStrategy(),
+            VentureType.MARKETPLACE: MarketplaceVentureStrategy()
+        }
+        
+        # Portfolio strategy for multi-venture optimization
+        self.portfolio_strategy = VenturePortfolioStrategy()
+    
+    async def reason(self, query: str, context: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Generate venture strategy based on query and context.
+        
+        Args:
+            query: The venture strategy query
+            context: Additional context and parameters
+            
+        Returns:
+            Dict containing venture strategy and confidence scores
+        """
+        try:
+            # Determine venture type from query/context
+            venture_type = self._determine_venture_type(query, context)
+            
+            # Get strategy for venture type
+            strategy = self.strategies.get(venture_type)
+            if not strategy:
+                raise ValueError(f"Unsupported venture type: {venture_type}")
+            
+            # Generate strategy
+            strategy_result = await strategy.reason(query, context)
+            
+            # Get portfolio analysis
+            portfolio_result = await self.portfolio_strategy.reason(query, context)
+            
+            # Combine results
+            combined_result = self._combine_results(
+                strategy_result,
+                portfolio_result,
+                venture_type
+            )
+            
+            return {
+                'answer': self._format_strategy(combined_result),
+                'confidence': combined_result.get('confidence', 0.0),
+                'venture_type': venture_type.value,
+                'strategy': strategy_result,
+                'portfolio_analysis': portfolio_result
+            }
+            
+        except Exception as e:
+            logging.error(f"Venture strategy generation failed: {str(e)}")
+            return {
+                'error': f"Venture strategy generation failed: {str(e)}",
+                'confidence': 0.0
+            }
+    
+    def _determine_venture_type(self, query: str, context: Dict[str, Any]) -> VentureType:
+        """Determine venture type from query and context."""
+        # Use context if available
+        if 'venture_type' in context:
+            return VentureType(context['venture_type'])
+        
+        # Simple keyword matching
+        query_lower = query.lower()
+        if any(term in query_lower for term in ['ai', 'ml', 'model', 'neural']):
+            return VentureType.AI_STARTUP
+        elif any(term in query_lower for term in ['saas', 'software', 'cloud']):
+            return VentureType.SAAS
+        elif any(term in query_lower for term in ['automate', 'automation', 'workflow']):
+            return VentureType.AUTOMATION_SERVICE
+        elif any(term in query_lower for term in ['data', 'analytics', 'insights']):
+            return VentureType.DATA_ANALYTICS
+        elif any(term in query_lower for term in ['api', 'service', 'endpoint']):
+            return VentureType.API_SERVICE
+        elif any(term in query_lower for term in ['marketplace', 'platform', 'network']):
+            return VentureType.MARKETPLACE
+        
+        # Default to AI startup if unclear
+        return VentureType.AI_STARTUP
+    
+    def _combine_results(
+        self,
+        strategy_result: Dict[str, Any],
+        portfolio_result: Dict[str, Any],
+        venture_type: VentureType
+    ) -> Dict[str, Any]:
+        """Combine strategy and portfolio results."""
+        return {
+            'venture_type': venture_type.value,
+            'strategy': strategy_result.get('strategy', {}),
+            'metrics': strategy_result.get('metrics', {}),
+            'portfolio_fit': portfolio_result.get('portfolio_fit', {}),
+            'recommendations': strategy_result.get('recommendations', []),
+            'confidence': min(
+                strategy_result.get('confidence', 0.0),
+                portfolio_result.get('confidence', 0.0)
+            )
+        }
+    
+    def _format_strategy(self, result: Dict[str, Any]) -> str:
+        """Format venture strategy into readable text."""
+        sections = []
+        
+        # Venture type
+        sections.append(f"Venture Type: {result['venture_type'].replace('_', ' ').title()}")
+        
+        # Strategy overview
+        if 'strategy' in result:
+            strategy = result['strategy']
+            sections.append("\nStrategy Overview:")
+            for key, value in strategy.items():
+                sections.append(f"- {key.replace('_', ' ').title()}: {value}")
+        
+        # Key metrics
+        if 'metrics' in result:
+            metrics = result['metrics']
+            sections.append("\nKey Metrics:")
+            for key, value in metrics.items():
+                if isinstance(value, (int, float)):
+                    sections.append(f"- {key.replace('_', ' ').title()}: {value:.2f}")
+                else:
+                    sections.append(f"- {key.replace('_', ' ').title()}: {value}")
+        
+        # Portfolio fit
+        if 'portfolio_fit' in result:
+            fit = result['portfolio_fit']
+            sections.append("\nPortfolio Analysis:")
+            for key, value in fit.items():
+                sections.append(f"- {key.replace('_', ' ').title()}: {value}")
+        
+        # Recommendations
+        if 'recommendations' in result:
+            recs = result['recommendations']
+            sections.append("\nKey Recommendations:")
+            for rec in recs:
+                sections.append(f"- {rec}")
+        
+        return "\n".join(sections)