euriai 1.0.15__py3-none-any.whl → 1.0.17__py3-none-any.whl

euriai/__init__.py

@@ -1,204 +1,204 @@
-"""
-Euri AI Python SDK
-
-A comprehensive Python SDK for the Euri AI API with integrations for popular frameworks.
-"""
-
-__version__ = "1.0.15"
-
-# Core imports that should always work
-try:
-    from .client import EuriaiClient
-except ImportError as e:
-    print(f"Warning: Could not import EuriaiClient: {e}")
-    EuriaiClient = None
-
-try:
-    from .embedding import EuriaiEmbeddingClient
-    # Backward compatibility alias
-    EuriaiEmbedding = EuriaiEmbeddingClient
-except ImportError as e:
-    print(f"Warning: Could not import EuriaiEmbeddingClient: {e}")
-    EuriaiEmbeddingClient = None
-    EuriaiEmbedding = None
-
-# Main exports (only include what was successfully imported)
-__all__ = []
-if EuriaiClient is not None:
-    __all__.append("EuriaiClient")
-if EuriaiEmbeddingClient is not None:
-    __all__.extend(["EuriaiEmbeddingClient", "EuriaiEmbedding"])
-
-
-# Helper functions for optional dependencies
-def check_optional_dependency(package_name: str, integration_name: str, install_extra: str = None) -> bool:
-    """
-    Check if an optional dependency is installed and provide helpful installation instructions.
-    
-    Args:
-        package_name: The actual package name to import
-        integration_name: The friendly name for the integration
-        install_extra: The extras_require key for pip install euriai[extra]
-    
-    Returns:
-        bool: True if package is available, False otherwise
-        
-    Raises:
-        ImportError: With helpful installation instructions
-    """
-    try:
-        __import__(package_name)
-        return True
-    except ImportError:
-        extra_option = f"euriai[{install_extra}]" if install_extra else f"euriai[{integration_name.lower()}]"
-        
-        error_msg = (
-            f"{integration_name} is not installed. Please install it using one of these methods:\n\n"
-            f"Option 1 (Recommended): Install with euriai extras:\n"
-            f"  pip install {extra_option}\n\n"
-            f"Option 2: Install {integration_name} directly:\n"
-            f"  pip install {package_name}\n\n"
-            f"Option 3: Install all euriai integrations:\n"
-            f"  pip install euriai[all]\n"
-        )
-        
-        raise ImportError(error_msg)
-
-
-def install_optional_dependency(package_name: str, integration_name: str, install_extra: str = None) -> bool:
-    """
-    Attempt to automatically install an optional dependency (USE WITH CAUTION).
-    
-    This function is provided for convenience but automatic installation can be risky.
-    It's generally better to install dependencies manually.
-    
-    Args:
-        package_name: The actual package name to install
-        integration_name: The friendly name for the integration  
-        install_extra: The extras_require key for pip install euriai[extra]
-    
-    Returns:
-        bool: True if installation succeeded, False otherwise
-    """
-    import subprocess
-    import sys
-    
-    try:
-        # Try to import first
-        __import__(package_name)
-        print(f"✓ {integration_name} is already installed")
-        return True
-    except ImportError:
-        pass
-    
-    # Ask user for confirmation
-    extra_option = f"euriai[{install_extra}]" if install_extra else f"euriai[{integration_name.lower()}]"
-    
-    print(f"🔍 {integration_name} is not installed.")
-    print(f"📦 Recommended installation: pip install {extra_option}")
-    
-    response = input(f"Would you like to automatically install {package_name}? (y/N): ").lower()
-    
-    if response in ['y', 'yes']:
-        try:
-            print(f"📥 Installing {package_name}...")
-            subprocess.check_call([sys.executable, "-m", "pip", "install", package_name])
-            print(f"✅ {integration_name} installed successfully!")
-            return True
-        except subprocess.CalledProcessError as e:
-            print(f"❌ Failed to install {package_name}: {e}")
-            print(f"💡 Try manually: pip install {extra_option}")
-            return False
-    else:
-        print(f"💡 To install manually run: pip install {extra_option}")
-        return False
-
-
-# Lazy loading functions for optional integrations
-def _get_langchain():
-    """Lazy import for LangChain integration."""
-    try:
-        from . import langchain
-        return langchain
-    except ImportError:
-        check_optional_dependency("langchain-core", "LangChain", "langchain")
-
-def _get_crewai():
-    """Lazy import for CrewAI integration."""
-    try:
-        from . import crewai
-        return crewai
-    except ImportError:
-        check_optional_dependency("crewai", "CrewAI", "crewai")
-
-def _get_autogen():
-    """Lazy import for AutoGen integration."""
-    try:
-        from . import autogen
-        return autogen
-    except ImportError:
-        check_optional_dependency("pyautogen", "AutoGen", "autogen")
-
-def _get_smolagents():
-    """Lazy import for SmolAgents integration."""
-    try:
-        from . import smolagents
-        return smolagents
-    except ImportError:
-        check_optional_dependency("smolagents", "SmolAgents", "smolagents")
-
-def _get_langgraph():
-    """Lazy import for LangGraph integration."""
-    try:
-        from . import langgraph
-        return langgraph
-    except ImportError:
-        check_optional_dependency("langgraph", "LangGraph", "langgraph")
-
-def _get_llamaindex():
-    """Lazy import for LlamaIndex integration."""
-    try:
-        from . import llamaindex
-        return llamaindex
-    except ImportError:
-        check_optional_dependency("llama-index", "LlamaIndex", "llama-index")
-
-
-# Create lazy loading properties
-class _LazyLoader:
-    """Lazy loader for optional integrations."""
-    
-    @property
-    def langchain(self):
-        return _get_langchain()
-    
-    @property
-    def crewai(self):
-        return _get_crewai()
-    
-    @property
-    def autogen(self):
-        return _get_autogen()
-    
-    @property
-    def smolagents(self):
-        return _get_smolagents()
-    
-    @property
-    def langgraph(self):
-        return _get_langgraph()
-    
-    @property
-    def llamaindex(self):
-        return _get_llamaindex()
-
-
-# Create the lazy loader instance
-_lazy = _LazyLoader()
-
-# Make the integrations available as module-level attributes
-def __getattr__(name: str):
-    """Handle lazy loading of optional integrations."""
-    if hasattr(_lazy, name):
-        return getattr(_lazy, name)
+"""
+Euri AI Python SDK
+
+A comprehensive Python SDK for the Euri AI API with integrations for popular frameworks.
+"""
+
+__version__ = "1.0.17"
+
+# Core imports that should always work
+try:
+    from .client import EuriaiClient
+except ImportError as e:
+    print(f"Warning: Could not import EuriaiClient: {e}")
+    EuriaiClient = None
+
+try:
+    from .embedding import EuriaiEmbeddingClient
+    # Backward compatibility alias
+    EuriaiEmbedding = EuriaiEmbeddingClient
+except ImportError as e:
+    print(f"Warning: Could not import EuriaiEmbeddingClient: {e}")
+    EuriaiEmbeddingClient = None
+    EuriaiEmbedding = None
+
+# Main exports (only include what was successfully imported)
+__all__ = []
+if EuriaiClient is not None:
+    __all__.append("EuriaiClient")
+if EuriaiEmbeddingClient is not None:
+    __all__.extend(["EuriaiEmbeddingClient", "EuriaiEmbedding"])
+
+
+# Helper functions for optional dependencies
+def check_optional_dependency(package_name: str, integration_name: str, install_extra: str = None) -> bool:
+    """
+    Check if an optional dependency is installed and provide helpful installation instructions.
+    
+    Args:
+        package_name: The actual package name to import
+        integration_name: The friendly name for the integration
+        install_extra: The extras_require key for pip install euriai[extra]
+    
+    Returns:
+        bool: True if package is available, False otherwise
+        
+    Raises:
+        ImportError: With helpful installation instructions
+    """
+    try:
+        __import__(package_name)
+        return True
+    except ImportError:
+        extra_option = f"euriai[{install_extra}]" if install_extra else f"euriai[{integration_name.lower()}]"
+        
+        error_msg = (
+            f"{integration_name} is not installed. Please install it using one of these methods:\n\n"
+            f"Option 1 (Recommended): Install with euriai extras:\n"
+            f"  pip install {extra_option}\n\n"
+            f"Option 2: Install {integration_name} directly:\n"
+            f"  pip install {package_name}\n\n"
+            f"Option 3: Install all euriai integrations:\n"
+            f"  pip install euriai[all]\n"
+        )
+        
+        raise ImportError(error_msg)
+
+
+def install_optional_dependency(package_name: str, integration_name: str, install_extra: str = None) -> bool:
+    """
+    Attempt to automatically install an optional dependency (USE WITH CAUTION).
+    
+    This function is provided for convenience but automatic installation can be risky.
+    It's generally better to install dependencies manually.
+    
+    Args:
+        package_name: The actual package name to install
+        integration_name: The friendly name for the integration  
+        install_extra: The extras_require key for pip install euriai[extra]
+    
+    Returns:
+        bool: True if installation succeeded, False otherwise
+    """
+    import subprocess
+    import sys
+    
+    try:
+        # Try to import first
+        __import__(package_name)
+        print(f"✓ {integration_name} is already installed")
+        return True
+    except ImportError:
+        pass
+    
+    # Ask user for confirmation
+    extra_option = f"euriai[{install_extra}]" if install_extra else f"euriai[{integration_name.lower()}]"
+    
+    print(f"🔍 {integration_name} is not installed.")
+    print(f"📦 Recommended installation: pip install {extra_option}")
+    
+    response = input(f"Would you like to automatically install {package_name}? (y/N): ").lower()
+    
+    if response in ['y', 'yes']:
+        try:
+            print(f"📥 Installing {package_name}...")
+            subprocess.check_call([sys.executable, "-m", "pip", "install", package_name])
+            print(f"✅ {integration_name} installed successfully!")
+            return True
+        except subprocess.CalledProcessError as e:
+            print(f"❌ Failed to install {package_name}: {e}")
+            print(f"💡 Try manually: pip install {extra_option}")
+            return False
+    else:
+        print(f"💡 To install manually run: pip install {extra_option}")
+        return False
+
+
+# Lazy loading functions for optional integrations
+def _get_langchain():
+    """Lazy import for LangChain integration."""
+    try:
+        from . import langchain
+        return langchain
+    except ImportError:
+        check_optional_dependency("langchain-core", "LangChain", "langchain")
+
+def _get_crewai():
+    """Lazy import for CrewAI integration."""
+    try:
+        from . import crewai
+        return crewai
+    except ImportError:
+        check_optional_dependency("crewai", "CrewAI", "crewai")
+
+def _get_autogen():
+    """Lazy import for AutoGen integration."""
+    try:
+        from . import autogen
+        return autogen
+    except ImportError:
+        check_optional_dependency("pyautogen", "AutoGen", "autogen")
+
+def _get_smolagents():
+    """Lazy import for SmolAgents integration."""
+    try:
+        from . import smolagents
+        return smolagents
+    except ImportError:
+        check_optional_dependency("smolagents", "SmolAgents", "smolagents")
+
+def _get_langgraph():
+    """Lazy import for LangGraph integration."""
+    try:
+        from . import langgraph
+        return langgraph
+    except ImportError:
+        check_optional_dependency("langgraph", "LangGraph", "langgraph")
+
+def _get_llamaindex():
+    """Lazy import for LlamaIndex integration."""
+    try:
+        from . import llamaindex
+        return llamaindex
+    except ImportError:
+        check_optional_dependency("llama-index", "LlamaIndex", "llama-index")
+
+
+# Create lazy loading properties
+class _LazyLoader:
+    """Lazy loader for optional integrations."""
+    
+    @property
+    def langchain(self):
+        return _get_langchain()
+    
+    @property
+    def crewai(self):
+        return _get_crewai()
+    
+    @property
+    def autogen(self):
+        return _get_autogen()
+    
+    @property
+    def smolagents(self):
+        return _get_smolagents()
+    
+    @property
+    def langgraph(self):
+        return _get_langgraph()
+    
+    @property
+    def llamaindex(self):
+        return _get_llamaindex()
+
+
+# Create the lazy loader instance
+_lazy = _LazyLoader()
+
+# Make the integrations available as module-level attributes
+def __getattr__(name: str):
+    """Handle lazy loading of optional integrations."""
+    if hasattr(_lazy, name):
+        return getattr(_lazy, name)
     raise AttributeError(f"module '{__name__}' has no attribute '{name}'")

euriai/langgraph.py

@@ -248,6 +248,7 @@ class EuriaiLangGraph:
         default_temperature: float = 0.7,
         default_max_tokens: int = 1000,
         enable_checkpointing: bool = True,
+        enable_usage_tracking: bool = True,
         verbose: bool = True
     ):
         """
@@ -260,6 +261,7 @@ class EuriaiLangGraph:
             default_temperature: Default temperature
             default_max_tokens: Default max tokens
             enable_checkpointing: Enable workflow checkpointing
+            enable_usage_tracking: Enable usage statistics tracking
             verbose: Enable verbose logging
         """
         if not LANGGRAPH_AVAILABLE:
@@ -273,6 +275,7 @@ class EuriaiLangGraph:
         self.default_model = default_model
         self.default_temperature = default_temperature
         self.default_max_tokens = default_max_tokens
+        self.enable_usage_tracking = enable_usage_tracking
         self.verbose = verbose
         
         # Initialize graph
@@ -297,8 +300,10 @@ class EuriaiLangGraph:
             "total_runs": 0,
             "total_nodes_executed": 0,
             "avg_execution_time": 0.0,
+            "total_api_calls": 0,
             "errors": 0,
-            "successful_runs": 0
+            "successful_runs": 0,
+            "ai_nodes": {}  # Node-specific statistics
         }
         
         # Thread pool for async operations
@@ -344,6 +349,15 @@ class EuriaiLangGraph:
         self.nodes[name] = ai_node
         self.graph.add_node(name, ai_node)
         
+        # Initialize node-specific statistics
+        if self.enable_usage_tracking:
+            self.usage_stats["ai_nodes"][name] = {
+                "total_calls": 0,
+                "total_tokens": 0,
+                "errors": 0,
+                "avg_response_time": 0.0
+            }
+        
         if self.verbose:
             print(f"Added AI node: {name} (model: {ai_node.model})")
     
@@ -573,6 +587,17 @@ class EuriaiLangGraph:
             if self.compiled_graph is None:
                 self.compile_graph()
             
+            # Prepare config for checkpointer if needed
+            if config is None:
+                config = {}
+            
+            # If checkpointer is enabled and no thread_id provided, create one
+            if self.checkpointer is not None and "configurable" not in config:
+                import uuid
+                config["configurable"] = {
+                    "thread_id": str(uuid.uuid4())
+                }
+            
             # Execute workflow asynchronously
             result = await self.compiled_graph.ainvoke(input_state, config=config)
             
@@ -613,6 +638,17 @@ class EuriaiLangGraph:
         if self.compiled_graph is None:
             self.compile_graph()
         
+        # Prepare config for checkpointer if needed
+        if config is None:
+            config = {}
+        
+        # If checkpointer is enabled and no thread_id provided, create one
+        if self.checkpointer is not None and "configurable" not in config:
+            import uuid
+            config["configurable"] = {
+                "thread_id": str(uuid.uuid4())
+            }
+        
         for chunk in self.compiled_graph.stream(input_state, config=config):
             yield chunk
     
@@ -634,9 +670,119 @@ class EuriaiLangGraph:
         if self.compiled_graph is None:
             self.compile_graph()
         
+        # Prepare config for checkpointer if needed
+        if config is None:
+            config = {}
+        
+        # If checkpointer is enabled and no thread_id provided, create one
+        if self.checkpointer is not None and "configurable" not in config:
+            import uuid
+            config["configurable"] = {
+                "thread_id": str(uuid.uuid4())
+            }
+        
         async for chunk in self.compiled_graph.astream(input_state, config=config):
             yield chunk
     
+    async def abatch(
+        self,
+        input_states: List[Dict[str, Any]],
+        config: Optional[Dict[str, Any]] = None
+    ) -> List[Dict[str, Any]]:
+        """
+        Async batch processing of multiple inputs.
+        
+        Args:
+            input_states: List of input states to process
+            config: Optional configuration for the run
+            
+        Returns:
+            List of final states after workflow execution
+        """
+        # Prepare config for checkpointer if needed
+        if config is None:
+            config = {}
+        
+        # If checkpointer is enabled and no thread_id provided, create one
+        if self.checkpointer is not None and "configurable" not in config:
+            import uuid
+            config["configurable"] = {
+                "thread_id": str(uuid.uuid4())
+            }
+        
+        # Process all inputs concurrently
+        results = []
+        for input_state in input_states:
+            result = await self.arun(input_state, config=config)
+            results.append(result)
+        
+        return results
+    
+    def get_usage_stats(self) -> Dict[str, Any]:
+        """
+        Get comprehensive usage statistics for the workflow.
+        
+        Returns:
+            Dictionary containing usage statistics including:
+            - total_runs: Total number of workflow runs
+            - successful_runs: Number of successful runs
+            - errors: Number of errors
+            - avg_execution_time: Average execution time per run
+            - total_api_calls: Total API calls made
+            - ai_nodes: Node-specific statistics
+        """
+        if not self.enable_usage_tracking:
+            return {"message": "Usage tracking is disabled"}
+        
+        # Update AI node statistics from individual nodes
+        for node_name, ai_node in self.ai_nodes.items():
+            if node_name in self.usage_stats["ai_nodes"]:
+                node_stats = ai_node.usage_stats
+                self.usage_stats["ai_nodes"][node_name].update({
+                    "total_calls": node_stats["total_calls"],
+                    "total_tokens": node_stats["total_tokens"],
+                    "errors": node_stats["errors"],
+                    "avg_response_time": node_stats["avg_response_time"]
+                })
+                
+                # Add to total API calls
+                self.usage_stats["total_api_calls"] += node_stats["total_calls"]
+        
+        return self.usage_stats.copy()
+    
+    def reset_usage_stats(self) -> None:
+        """Reset all usage statistics."""
+        if not self.enable_usage_tracking:
+            return
+        
+        self.usage_stats = {
+            "total_runs": 0,
+            "total_nodes_executed": 0,
+            "avg_execution_time": 0.0,
+            "total_api_calls": 0,
+            "errors": 0,
+            "successful_runs": 0,
+            "ai_nodes": {}
+        }
+        
+        # Reset individual AI node stats
+        for ai_node in self.ai_nodes.values():
+            ai_node.usage_stats = {
+                "total_calls": 0,
+                "total_tokens": 0,
+                "errors": 0,
+                "avg_response_time": 0.0
+            }
+        
+        # Reinitialize AI node stats
+        for name in self.ai_nodes.keys():
+            self.usage_stats["ai_nodes"][name] = {
+                "total_calls": 0,
+                "total_tokens": 0,
+                "errors": 0,
+                "avg_response_time": 0.0
+            }
+    
     def create_workflow_pattern(self, pattern_type: WorkflowType, **kwargs) -> None:
         """
         Create a pre-defined workflow pattern.

{euriai-1.0.15.dist-info → euriai-1.0.17.dist-info}/METADATA

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

{euriai-1.0.15.dist-info → euriai-1.0.17.dist-info}/RECORD

@@ -1,4 +1,4 @@
-euriai/__init__.py,sha256=BW-vN8t7z6wkpm_Vu4xM-roD2NiMhF-IKb6MJV1KzKM,6630
+euriai/__init__.py,sha256=MQ2FHAw6ruOUDyQAlAqC7cW9Xhg2qhjVb6tX7r54F1w,6427
 euriai/autogen.py,sha256=z1WHftUgu3_Sn8zDXmf31onikS0p8TwH5JE4llL7ogk,21144
 euriai/cli.py,sha256=hF1wiiL2QQSfWf8WlLQyNVDBd4YkbiwmMSoPxVbyPTM,3290
 euriai/client.py,sha256=L-o6hv9N3md-l-hz-kz5nYVaaZqnrREZlo_0jguhF7E,4066
@@ -8,12 +8,12 @@ euriai/embedding.py,sha256=uP66Ph1k9Ou6J5RAkztJxlfyj0S0MESOvZ4ulhnVo-o,1270
 euriai/euri_chat.py,sha256=DEAiet1ReRwB4ljkPYaTl1Nb5uc20-JF-3PQjGQZXk4,3567
 euriai/euri_embed.py,sha256=g7zs1G-ZBDJjOGJtkkfIcV4LPtRcm9wpVWmrfMGn5EM,2919
 euriai/langchain.py,sha256=gVF9eh21RC1WtDn7SQoEREUDqOObm5IRx6BFZtB5xcc,34968
-euriai/langgraph.py,sha256=YTApEQ5gte_HI06x_zMBiNt1O87JlVspaWref954_7I,34636
+euriai/langgraph.py,sha256=q29D7tg9_7gXr-_uWOMRpOsPh-GRzZOykNGuBFoXgBc,39923
 euriai/llamaindex.py,sha256=c-ujod2bjL6QIvfAyuIxm1SvSCS00URFElYybKQ5Ew0,26551
 euriai/n8n.py,sha256=hjkckqyW_hZNL78UkBCof1WvKCKCIjwdvZdAgx6NrB8,3764
 euriai/smolagents.py,sha256=xlixGx2IWzAPTpSJGsYIK2L-SHGY9Mw1-8GbwVsEYtU,28507
-euriai-1.0.15.dist-info/METADATA,sha256=6ky-wJh84rTRc521m-nHTFXYbvtmRPaxQ83JmbfXTg8,6807
-euriai-1.0.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-euriai-1.0.15.dist-info/entry_points.txt,sha256=9OkET8KIGcsjQn8UlnpPKRT75s2KW34jq1__1SXtpMA,43
-euriai-1.0.15.dist-info/top_level.txt,sha256=TG1htJ8cuD62MXn-NJ7DVF21QHY16w6M_QgfF_Er_EQ,7
-euriai-1.0.15.dist-info/RECORD,,
+euriai-1.0.17.dist-info/METADATA,sha256=SeWBCt2LKsO9cCeZlX0cBihPuFUGCCCazRnsr2Z2ByA,6807
+euriai-1.0.17.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+euriai-1.0.17.dist-info/entry_points.txt,sha256=9OkET8KIGcsjQn8UlnpPKRT75s2KW34jq1__1SXtpMA,43
+euriai-1.0.17.dist-info/top_level.txt,sha256=TG1htJ8cuD62MXn-NJ7DVF21QHY16w6M_QgfF_Er_EQ,7
+euriai-1.0.17.dist-info/RECORD,,