euriai 1.0.17__tar.gz → 1.0.19__tar.gz

{euriai-1.0.17 → euriai-1.0.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: euriai
-Version: 1.0.17
+Version: 1.0.19
 Summary: Python client for Euri API (euron.one) with CLI, LangChain, and LlamaIndex integration
 Author: Euri
 Author-email: tech@euron.one

{euriai-1.0.17 → euriai-1.0.19}/euriai/__init__.py

@@ -4,7 +4,7 @@ Euri AI Python SDK
 A comprehensive Python SDK for the Euri AI API with integrations for popular frameworks.
 """
 
-__version__ = "1.0.17"
+__version__ = "1.0.19"
 
 # Core imports that should always work
 try:

{euriai-1.0.17 → euriai-1.0.19}/euriai/langgraph.py

@@ -112,7 +112,9 @@ class EuriaiAINode:
         max_tokens: int = 1000,
         system_message: Optional[str] = None,
         output_parser: Optional[Callable[[str], Any]] = None,
-        error_handler: Optional[Callable[[Exception], Any]] = None
+        error_handler: Optional[Callable[[Exception], Any]] = None,
+        max_retries: int = 0,
+        retry_delay: float = 1.0
     ):
         """
         Initialize an AI node.
@@ -127,6 +129,8 @@ class EuriaiAINode:
             system_message: Optional system message
             output_parser: Function to parse AI output
             error_handler: Function to handle errors
+            max_retries: Maximum number of retries on error (default: 0)
+            retry_delay: Delay between retries in seconds (default: 1.0)
         """
         self.name = name
         self.prompt_template = prompt_template
@@ -136,6 +140,8 @@ class EuriaiAINode:
         self.system_message = system_message
         self.output_parser = output_parser
         self.error_handler = error_handler
+        self.max_retries = max_retries
+        self.retry_delay = retry_delay
         
         # Initialize client
         self.client = EuriaiClient(api_key=api_key, model=model)
@@ -149,58 +155,79 @@ class EuriaiAINode:
         }
     
     def __call__(self, state: Dict[str, Any]) -> Dict[str, Any]:
-        """Execute the AI node."""
+        """Execute the AI node with retry logic."""
         start_time = time.time()
+        last_exception = None
         
-        try:
-            # Format prompt with state variables
-            formatted_prompt = self.prompt_template.format(**state)
-            
-            # Prepare user prompt (combine system message if provided)
-            user_prompt = formatted_prompt
-            if self.system_message:
-                # If there's a system message, combine it with the user prompt
-                user_prompt = f"System: {self.system_message}\n\nUser: {formatted_prompt}"
-            
-            # Make API call
-            response = self.client.generate_completion(
-                prompt=user_prompt,
-                temperature=self.temperature,
-                max_tokens=self.max_tokens
-            )
-            
-            # Extract content
-            content = response.get("choices", [{}])[0].get("message", {}).get("content", "")
-            
-            # Parse output if parser provided
-            if self.output_parser:
-                parsed_output = self.output_parser(content)
-            else:
-                parsed_output = content
-            
-            # Update usage stats
-            self.usage_stats["total_calls"] += 1
-            response_time = time.time() - start_time
-            self.usage_stats["avg_response_time"] = (
-                (self.usage_stats["avg_response_time"] * (self.usage_stats["total_calls"] - 1) + response_time)
-                / self.usage_stats["total_calls"]
-            )
-            
-            # Update state
-            state[f"{self.name}_output"] = parsed_output
-            state[f"{self.name}_raw_response"] = content
-            
-            return state
-            
-        except Exception as e:
-            self.usage_stats["errors"] += 1
-            
-            if self.error_handler:
-                return self.error_handler(e)
-            else:
-                logging.error(f"Error in AI node {self.name}: {e}")
-                state[f"{self.name}_error"] = str(e)
+        for attempt in range(self.max_retries + 1):  # +1 for initial attempt
+            try:
+                # Format prompt with state variables
+                formatted_prompt = self.prompt_template.format(**state)
+                
+                # Prepare user prompt (combine system message if provided)
+                user_prompt = formatted_prompt
+                if self.system_message:
+                    # If there's a system message, combine it with the user prompt
+                    user_prompt = f"System: {self.system_message}\n\nUser: {formatted_prompt}"
+                
+                # Make API call
+                response = self.client.generate_completion(
+                    prompt=user_prompt,
+                    temperature=self.temperature,
+                    max_tokens=self.max_tokens
+                )
+                
+                # Extract content
+                content = response.get("choices", [{}])[0].get("message", {}).get("content", "")
+                
+                # Parse output if parser provided
+                if self.output_parser:
+                    parsed_output = self.output_parser(content)
+                else:
+                    parsed_output = content
+                
+                # Update usage stats
+                self.usage_stats["total_calls"] += 1
+                response_time = time.time() - start_time
+                self.usage_stats["avg_response_time"] = (
+                    (self.usage_stats["avg_response_time"] * (self.usage_stats["total_calls"] - 1) + response_time)
+                    / self.usage_stats["total_calls"]
+                )
+                
+                # Update state
+                state[f"{self.name}_output"] = parsed_output
+                state[f"{self.name}_raw_response"] = content
+                
                 return state
+                
+            except Exception as e:
+                last_exception = e
+                self.usage_stats["errors"] += 1
+                
+                # If we haven't exhausted retries, wait and try again
+                if attempt < self.max_retries:
+                    logging.warning(f"AI node {self.name} failed (attempt {attempt + 1}/{self.max_retries + 1}): {e}")
+                    time.sleep(self.retry_delay)
+                    continue
+                
+                # All retries exhausted, handle error
+                if self.error_handler:
+                    error_result = self.error_handler(e)
+                    if isinstance(error_result, dict):
+                        # Merge error handler result with state
+                        state.update(error_result)
+                        return state
+                    else:
+                        state[f"{self.name}_error_handler_result"] = error_result
+                        return state
+                else:
+                    logging.error(f"Error in AI node {self.name} after {self.max_retries + 1} attempts: {e}")
+                    state[f"{self.name}_error"] = str(e)
+                    state["error_handled"] = False
+                    return state
+        
+        # Should never reach here, but just in case
+        return state
     
     async def acall(self, state: Dict[str, Any]) -> Dict[str, Any]:
         """Async version of the AI node execution."""
@@ -318,7 +345,9 @@ class EuriaiLangGraph:
         max_tokens: Optional[int] = None,
         system_message: Optional[str] = None,
         output_parser: Optional[Callable[[str], Any]] = None,
-        error_handler: Optional[Callable[[Exception], Any]] = None
+        error_handler: Optional[Callable[[Exception], Any]] = None,
+        max_retries: int = 0,
+        retry_delay: float = 1.0
     ) -> None:
         """
         Add an AI-powered node to the graph.
@@ -332,6 +361,8 @@ class EuriaiLangGraph:
             system_message: System message for the node
             output_parser: Function to parse AI output
             error_handler: Function to handle errors
+            max_retries: Maximum number of retries on error (default: 0)
+            retry_delay: Delay between retries in seconds (default: 1.0)
         """
         ai_node = EuriaiAINode(
             name=name,
@@ -342,7 +373,9 @@ class EuriaiLangGraph:
             max_tokens=max_tokens or self.default_max_tokens,
             system_message=system_message,
             output_parser=output_parser,
-            error_handler=error_handler
+            error_handler=error_handler,
+            max_retries=max_retries,
+            retry_delay=retry_delay
         )
         
         self.ai_nodes[name] = ai_node
@@ -413,6 +446,24 @@ class EuriaiLangGraph:
         if self.verbose:
             print(f"Added condition node: {name} with routes: {routes}")
     
+    def add_conditional_node(
+        self,
+        name: str,
+        condition_func: Callable[[Dict[str, Any]], str],
+        routes: Dict[str, str]
+    ) -> None:
+        """
+        Alias for add_condition_node for more intuitive naming.
+        
+        Add a conditional node that routes based on state.
+        
+        Args:
+            name: Node name
+            condition_func: Function that returns route key based on state
+            routes: Mapping of route keys to target nodes
+        """
+        return self.add_condition_node(name, condition_func, routes)
+    
     def add_embedding_node(
         self,
         name: str,
@@ -493,6 +544,40 @@ class EuriaiLangGraph:
         if self.verbose:
             print(f"Set finish point: {node_name}")
     
+    def add_conditional_edge(
+        self,
+        from_node: str,
+        condition_func: Callable[[Dict[str, Any]], str],
+        condition_map: Optional[Dict[str, str]] = None
+    ) -> None:
+        """
+        Add a conditional edge that routes based on state.
+        
+        Args:
+            from_node: Source node name
+            condition_func: Function that evaluates state and returns next node name
+            condition_map: Optional mapping of condition results to node names
+        """
+        if condition_map:
+            # Use condition map for routing
+            def router(state: Dict[str, Any]) -> str:
+                result = condition_func(state)
+                return condition_map.get(result, END)
+            
+            self.graph.add_conditional_edges(from_node, router, condition_map)
+        else:
+            # Direct function routing
+            self.graph.add_conditional_edges(from_node, condition_func)
+        
+        self.conditional_edges.append({
+            "source": from_node,
+            "condition": condition_func,
+            "condition_map": condition_map
+        })
+        
+        if self.verbose:
+            print(f"Added conditional edge from: {from_node}")
+    
     def compile_graph(self) -> CompiledStateGraph:
         """
         Compile the graph for execution.
@@ -1018,6 +1103,37 @@ class EuriaiLangGraph:
         
         return stats
     
+    def get_error_stats(self) -> Dict[str, Any]:
+        """Get error statistics for the workflow."""
+        error_stats = {
+            "total_errors": 0,
+            "ai_node_errors": {},
+            "error_rate": 0.0
+        }
+        
+        total_calls = 0
+        total_errors = 0
+        
+        # Collect error stats from AI nodes
+        for name, node in self.ai_nodes.items():
+            node_errors = node.usage_stats.get("errors", 0)
+            node_calls = node.usage_stats.get("total_calls", 0)
+            
+            error_stats["ai_node_errors"][name] = {
+                "errors": node_errors,
+                "total_calls": node_calls,
+                "error_rate": node_errors / max(node_calls, 1)
+            }
+            
+            total_errors += node_errors
+            total_calls += node_calls
+        
+        error_stats["total_errors"] = total_errors
+        error_stats["total_calls"] = total_calls
+        error_stats["error_rate"] = total_errors / max(total_calls, 1)
+        
+        return error_stats
+    
     def get_graph_structure(self) -> Dict[str, Any]:
         """Get the structure of the graph."""
         return {

{euriai-1.0.17 → euriai-1.0.19}/euriai.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: euriai
-Version: 1.0.17
+Version: 1.0.19
 Summary: Python client for Euri API (euron.one) with CLI, LangChain, and LlamaIndex integration
 Author: Euri
 Author-email: tech@euron.one

{euriai-1.0.17 → euriai-1.0.19}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="euriai",
-    version="1.0.17",
+    version="1.0.19",
     description="Python client for Euri API (euron.one) with CLI, LangChain, and LlamaIndex integration",
     long_description=open("README.md", encoding="utf-8").read(),
     long_description_content_type="text/markdown",