fairo 25.6.5__tar.gz → 25.7.2__tar.gz

{fairo-25.6.5 → fairo-25.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fairo
-Version: 25.6.5
+Version: 25.7.2
 Summary: SDK for interfacing with Fairo SaaS platform.
 Author-email: "Fairo Systems, Inc." <support@fairo.ai>
 License: Apache-2.0
@@ -11,7 +11,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Description-Content-Type: text/markdown
-Requires-Dist: mlflow<3.0.0,>=2.21.0
+Requires-Dist: mlflow<=3.1.1,>=3.1.0
 Requires-Dist: langchain<0.4.0,>=0.3.20
 Requires-Dist: langchain-aws<0.3.0,>=0.2.18
 Requires-Dist: langchain-community<0.4.0,>=0.3.20
@@ -19,6 +19,8 @@ Requires-Dist: langchain-core<0.4.0,>=0.3.49
 Requires-Dist: langchain-text-splitters<0.4.0,>=0.3.7
 Requires-Dist: psycopg2-binary<3.0.0,>=2.9.0
 Requires-Dist: langchain-postgres<0.1.0,>=0.0.14
+Requires-Dist: setuptools>=79.0.0
+Requires-Dist: pandas<3.0.0,>=2.0.0
 
 # Fairo SDK 
 

fairo-25.7.2/fairo/__init__.py

@@ -0,0 +1 @@
+__version__ = "25.7.2"

fairo-25.7.2/fairo/core/chat/__init__.py

@@ -0,0 +1 @@
+from .chat import ChatFairo

fairo-25.7.2/fairo/core/chat/chat.py

@@ -0,0 +1,227 @@
+
+from langchain_community.chat_models.mlflow import ChatMlflow
+from mlflow.deployments import get_deploy_client
+from mlflow.deployments.base import BaseDeploymentClient
+from fairo.settings import get_mlflow_gateway_chat_route, get_mlflow_gateway_uri, get_mlflow_user, get_mlflow_password
+import requests
+from requests.auth import HTTPBasicAuth
+import json
+import os
+
+class FairoDeploymentClient(BaseDeploymentClient):
+    """Custom deployment client that implements predict_stream for Fairo endpoints."""
+    
+    def __init__(self, target_uri: str, endpoint: str):
+        self.target_uri = target_uri
+        self.endpoint = endpoint
+        
+    def predict_stream(self, deployment_name=None, inputs=None, endpoint=None):
+        """
+        Implement streaming predictions by making HTTP requests to the Fairo gateway.
+        """
+        endpoint = endpoint or self.endpoint
+        
+        # Use the gateway URL to make streaming requests
+        gateway_url = f"{self.target_uri.rstrip('/')}/gateway/{endpoint}/invocations"
+        
+        headers = {
+            'Content-Type': 'application/json',
+            'Accept': 'text/event-stream'
+        }
+        
+        # Add authentication if needed
+        auth = None
+        if os.environ.get('MLFLOW_TRACKING_USERNAME') and os.environ.get('MLFLOW_TRACKING_PASSWORD'):
+            auth = HTTPBasicAuth(
+                os.environ.get('MLFLOW_TRACKING_USERNAME'),
+                os.environ.get('MLFLOW_TRACKING_PASSWORD')
+            )
+        
+        # Make streaming request
+        try:
+            response = requests.post(
+                gateway_url,
+                json={**inputs, "stream": True},
+                headers=headers,
+                auth=auth,
+            )
+            
+            if response.status_code != 200:
+                error_text = response.text
+                raise Exception(f"HTTP {response.status_code}: {error_text}")
+                
+            # Check if response is actually streaming
+            content_type = response.headers.get('content-type', '')
+            
+            chunk_count = 0
+            
+            # Parse streaming response
+            for line in response.iter_lines():
+                if line:
+                    line = line.decode('utf-8')
+                    
+                    # Handle different streaming formats
+                    if line.startswith('data: '):
+                        try:
+                            data_str = line[6:]  # Remove 'data: ' prefix
+                            if data_str.strip() == '[DONE]':
+                                break
+                            data = json.loads(data_str)
+                            chunk_count += 1
+                            yield data
+                        except json.JSONDecodeError as e:
+                            continue
+                    else:
+                        # Try parsing as direct JSON
+                        try:
+                            data = json.loads(line)
+                            chunk_count += 1
+                            yield data
+                        except json.JSONDecodeError:
+                            continue
+                            
+            
+            # If no chunks were yielded, fall back to non-streaming
+            if chunk_count == 0:
+                # Try to get the full response as JSON
+                try:
+                    if hasattr(response, 'json'):
+                        result = response.json()
+                        yield result
+                except:
+                    # Create a minimal response to avoid the error
+                    yield {
+                        "choices": [{
+                            "delta": {"content": "", "role": "assistant"},
+                            "finish_reason": "stop"
+                        }]
+                    }
+                    
+        except requests.exceptions.RequestException as e:
+            raise Exception(f"Request failed: {e}")
+    
+    def predict(self, deployment_name=None, inputs=None, endpoint=None):
+        """
+        Implement synchronous predictions by making HTTP requests to the Fairo gateway.
+        """
+        endpoint = endpoint or self.endpoint
+        
+        # Use the gateway URL to make requests
+        gateway_url = f"{self.target_uri.rstrip('/')}/gateway/{endpoint}/invocations"
+        
+        headers = {
+            'Content-Type': 'application/json',
+            'Accept': 'application/json'
+        }
+        
+        # Add authentication if needed
+        auth = None
+        if os.environ.get('MLFLOW_TRACKING_USERNAME') and os.environ.get('MLFLOW_TRACKING_PASSWORD'):
+            auth = HTTPBasicAuth(
+                os.environ.get('MLFLOW_TRACKING_USERNAME'),
+                os.environ.get('MLFLOW_TRACKING_PASSWORD')
+            )
+        
+        # Make request
+        response = requests.post(
+            gateway_url,
+            json=inputs,
+            headers=headers,
+            auth=auth
+        )
+        
+        if response.status_code != 200:
+            raise Exception(f"HTTP {response.status_code}: {response.text}")
+            
+        return response.json()
+    
+    def get_deployment(self, name, endpoint=None):
+        """Get deployment information."""
+        raise NotImplementedError("get_deployment not implemented")
+        
+    def list_deployments(self, endpoint=None):
+        """List available deployments."""
+        raise NotImplementedError("list_deployments not implemented")
+        
+    def get_endpoint(self, endpoint):
+        """Get endpoint information."""
+        raise NotImplementedError("get_endpoint not implemented")
+        
+    def list_endpoints(self):
+        """List available endpoints."""
+        raise NotImplementedError("list_endpoints not implemented")
+        
+    def create_deployment(self, name, config, endpoint=None):
+        """Create a new deployment."""
+        raise NotImplementedError("create_deployment not implemented")
+        
+    def update_deployment(self, name, config, endpoint=None):
+        """Update an existing deployment."""
+        raise NotImplementedError("update_deployment not implemented")
+        
+    def delete_deployment(self, name, endpoint=None):
+        """Delete a deployment."""
+        raise NotImplementedError("delete_deployment not implemented")
+        
+    def create_endpoint(self, name, config):
+        """Create a new endpoint."""
+        raise NotImplementedError("create_endpoint not implemented")
+        
+    def update_endpoint(self, name, config):
+        """Update an existing endpoint."""
+        raise NotImplementedError("update_endpoint not implemented")
+        
+    def delete_endpoint(self, name):
+        """Delete an endpoint."""
+        raise NotImplementedError("delete_endpoint not implemented")
+
+
+class ChatFairo(ChatMlflow):
+
+    def __init__(self, **kwargs):
+
+        # # TODO <- see if this can be improved
+        # os.environ["MLFLOW_TRACKING_USERNAME"] = get_mlflow_user()
+        # os.environ["MLFLOW_TRACKING_PASSWORD"] = get_mlflow_password()
+
+        super().__init__(
+            target_uri=os.environ.get('MLFLOW_GATEWAY_URI', get_mlflow_gateway_uri()),
+            endpoint=os.environ.get('MLFLOW_GATEWAY_ROUTE', get_mlflow_gateway_chat_route()),
+            **kwargs
+        )
+        
+        self._client = FairoDeploymentClient(self.target_uri, self.endpoint)
+
+    @property
+    def _target_uri(self):
+        return os.environ.get("MLFLOW_GATEWAY_URI", None)
+
+    @property
+    def _endpoint(self):
+        return os.environ.get("MLFLOW_GATEWAY_ROUTE", None)
+
+    def invoke(self, *args, **kwargs):
+        # Override invoke to use dynamic target_uri
+        self.target_uri = self._target_uri
+        self._client = FairoDeploymentClient(self.target_uri, self.endpoint)
+        return super().invoke(*args, **kwargs)
+
+
+class FairoChat(ChatMlflow):
+    def __init__(self, endpoint, **kwargs):
+        super().__init__(
+            target_uri=os.environ.get('MLFLOW_GATEWAY_URI', None),
+            endpoint=endpoint,
+            # extra_params={"workflow_run_id": workflow_run_id},
+            **kwargs
+        )
+
+    @property
+    def _target_uri(self):
+        return os.environ.get("MLFLOW_GATEWAY_URI", None)
+    
+    def invoke(self, *args, **kwargs):
+        # Override invoke to use dynamic target_uri
+        self.target_uri = self._target_uri
+        self._client = get_deploy_client(self.target_uri)
+        return super().invoke(*args, **kwargs)

fairo-25.7.2/fairo/core/execution/agent_serializer.py

@@ -0,0 +1,288 @@
+from typing import Any, Dict
+import mlflow
+import cloudpickle
+import os
+import sys
+from pathlib import Path
+from langchain_core.runnables import RunnableLambda, Runnable
+from langchain.chains import SimpleSequentialChain
+import logging
+import types
+import threading
+import pandas as pd
+logger = logging.getLogger(__name__)
+
+class CustomPythonModel(mlflow.pyfunc.PythonModel):
+    def __init__(self):
+        self.agent = None
+    
+    def __getstate__(self):
+        state = self.__dict__.copy()
+        state.pop("lock", None)
+    
+    def __setstate__(self, state):
+        self.__dict__.update(state)
+        self.lock = threading.Lock()
+    
+    def load_context(self, context):
+        import sys
+        import os
+        import shutil
+        
+        agent_code_path = context.model_config["agent_code"]
+        agent_code_dir = os.path.dirname(agent_code_path)
+        
+        if agent_code_dir not in sys.path:
+            sys.path.insert(0, agent_code_dir)
+        
+        for artifact_name, artifact_path in context.model_config.items():
+            if artifact_name.startswith("local_module_"):
+                module_name = artifact_name.replace("local_module_", "")
+                module_filename = f"{module_name}.py"
+                dest_path = os.path.join(agent_code_dir, module_filename)
+                
+                if not os.path.exists(dest_path):
+                    shutil.copy2(artifact_path, dest_path)
+                    print(f"Restored local module: {module_name}")
+        
+        try:
+            import agent_code
+            from agent_code import create_simple_agent
+            self.agent_func = create_simple_agent
+            self.agent = self.agent_func()
+        except ImportError as e:
+            raise ImportError(f"Failed to import agent_code: {e}")
+    
+    def predict(self, context, model_input):
+        if isinstance(model_input, list):
+            return [self.agent.run(query) for query in model_input]
+        else:
+            return self.agent.run(model_input)
+
+class AgentChainWrapper:
+    def __init__(self, chain_class = SimpleSequentialChain, agent_functions_list = []):
+        self.chain_class = chain_class
+        self.agents = [func() for func in agent_functions_list]
+        self.agent_functions = agent_functions_list
+    
+    def _wrap_agent_runnable(self, agent) -> RunnableLambda:
+        """
+        Wraps the agent's .run() method into a RunnableLambda with a custom function name.
+        Properly propagates errors instead of continuing to the next agent.
+        """
+        def base_fn(inputs: Dict[str, Any]) -> Dict[str, Any]:            
+            # Run the agent, but don't catch exceptions - let them propagate
+            # This will stop the entire pipeline on agent failure
+            return agent.invoke(inputs)
+            
+            # Check if result starts with "An error occurred" which indicates agent failure
+            # if isinstance(result, str) and result.startswith("An error occurred during execution:"):
+            #     # Propagate the error by raising an exception to stop the execution
+            #     raise RuntimeError(f"Agent {agent.__class__.__name__} failed: {result}")
+                
+            # return result
+
+        # Clone function and set custom name
+        fn_name = f"runnable_{agent.__class__.__name__.lower().replace(' ', '_')}"
+        runnable_fn = types.FunctionType(
+            base_fn.__code__,
+            base_fn.__globals__,
+            name=fn_name,
+            argdefs=base_fn.__defaults__,
+            closure=base_fn.__closure__,
+        )
+
+        return RunnableLambda(runnable_fn)
+    
+    def run(self, query):
+        result = query
+        def is_dataframe(obj) -> bool:
+            try:
+                return isinstance(obj, pd.DataFrame)
+            except Exception as e:
+                return False
+        if is_dataframe(result):
+            result = result.to_dict(orient='records')[0]
+        runnables = []
+        for agent in self.agents:
+            if isinstance(agent, Runnable):
+                runnables.append(agent)
+            else:
+                runnables.append(
+                    self._wrap_agent_runnable(agent)
+                )
+        if self.chain_class is SimpleSequentialChain:
+            pipeline = runnables[0]
+            for r in runnables[1:]:
+                pipeline = pipeline | r
+            if is_dataframe(query):
+                query = query.to_dict(orient='records')[0]
+            return pipeline.invoke(query)
+        chain = self.chain_class(
+            chains=runnables,
+        )
+        return chain.run(result)
+    
+    def predict(self, context = "", model_input = ""):
+        return self.run(model_input)
+
+class CustomChainModel(mlflow.pyfunc.PythonModel):
+    def __init__(self):
+        self.agent_chain = None
+        self.agents = []
+    
+    def __getstate__(self):
+        state = self.__dict__.copy()
+        state.pop("lock", None)
+    
+    def __setstate__(self, state):
+        self.__dict__.update(state)
+        self.lock = threading.Lock()
+    
+    def load_context(self, context):
+        import sys
+        import os
+        import shutil
+        import importlib.util
+        
+        # Get the directory where artifacts are stored
+        base_dir = os.path.dirname(list(context.artifacts.values())[0])
+        
+        if base_dir not in sys.path:
+            sys.path.insert(0, base_dir)
+        
+        # Restore local modules
+        for artifact_name, artifact_path in context.artifacts.items():
+            if artifact_name.startswith("local_module_"):
+                module_name = artifact_name.replace("local_module_", "")
+                module_filename = f"{module_name}.py"
+                dest_path = os.path.join(base_dir, module_filename)
+                
+                if not os.path.exists(dest_path):
+                    shutil.copy2(artifact_path, dest_path)
+                    print(f"Restored local module: {module_name}")
+        
+        # Load chain configuration
+        chain_config_path = context.artifacts["chain_config"]
+        spec = importlib.util.spec_from_file_location("chain_config", chain_config_path)
+        chain_config_module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(chain_config_module)
+        
+        chain_config = chain_config_module.CHAIN_CONFIG
+        
+        # Load each agent
+        agent_functions = []
+        for agent_info in chain_config["agents"]:
+            agent_code_file = agent_info["agent_code_file"]
+            function_name = agent_info["function_name"]
+            
+            # Load the agent module - handle the artifact key mapping
+            artifact_key = agent_code_file.replace(".py", "")
+            if artifact_key not in context.artifacts:
+                # Try with agent_code_ prefix for consistency
+                artifact_key = f"agent_code_{agent_info['name'].split('_')[-1]}"
+            agent_code_path = context.artifacts[artifact_key]
+            spec = importlib.util.spec_from_file_location("agent_module", agent_code_path)
+            agent_module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(agent_module)
+            
+            # Get the agent function
+            agent_function = getattr(agent_module, function_name)
+            agent_functions.append(agent_function)
+        
+        # Create the agent chain
+        self.agent_chain = AgentChainWrapper(agent_functions_list=agent_functions)
+    
+    def predict(self, context, model_input):
+        if isinstance(model_input, list):
+            return [self.agent_chain.run(query) for query in model_input]
+        else:
+            return self.agent_chain.run(model_input)
+
+class CrewAgentWrapper:
+    def __init__(self, agent_func=None):
+        if agent_func is not None:
+            # During logging phase
+            try:
+                from crew_agent import create_crew_agent
+                self.base_agent = create_crew_agent()
+            except ImportError:
+                raise ImportError("Could not import CrewAI agent functions")
+        else:
+            # During model loading phase
+            try:
+                from agent_code import create_crew_agent
+                self.base_agent = create_crew_agent()
+            except ImportError:
+                try:
+                    from crew_agent import create_crew_agent
+                    self.base_agent = create_crew_agent()
+                except ImportError:
+                    raise ImportError("Could not import CrewAI agent")
+    
+    def run(self, query):
+        try:
+            if hasattr(self, 'base_agent'):
+                # Import create_crew_with_task function
+                try:
+                    from agent_code import create_crew_with_task
+                except ImportError:
+                    from crew_agent import create_crew_with_task
+                
+                crew = create_crew_with_task(query)
+                result = crew.kickoff()
+                return str(result)
+            else:
+                return "Error: Agent not properly initialized"
+        except Exception as e:
+            print(f"Error running CrewAI crew: {e}")
+            return f"Error executing query '{query}': {str(e)}"
+    
+    def predict(self, context, model_input):
+        return self.run(model_input)
+
+class CustomCrewModel(mlflow.pyfunc.PythonModel):
+    def __init__(self):
+        self.agent = None
+    
+    def __getstate__(self):
+        state = self.__dict__.copy()
+        state.pop("lock", None)
+    
+    def __setstate__(self, state):
+        self.__dict__.update(state)
+        self.lock = threading.Lock()
+    
+    def load_context(self, context):
+        import sys
+        import os
+        import shutil
+        
+        agent_code_path = context.model_config["agent_code"]
+        agent_code_dir = os.path.dirname(agent_code_path)
+        
+        if agent_code_dir not in sys.path:
+            sys.path.insert(0, agent_code_dir)
+        
+        for artifact_name, artifact_path in context.model_config.items():
+            if artifact_name.startswith("local_module_"):
+                module_name = artifact_name.replace("local_module_", "")
+                module_filename = f"{module_name}.py"
+                dest_path = os.path.join(agent_code_dir, module_filename)
+                
+                if not os.path.exists(dest_path):
+                    shutil.copy2(artifact_path, dest_path)
+                    print(f"Restored local module: {module_name}")
+        
+        try:
+            import agent_code
+            from agent_code import CrewAgentWrapper
+            self.agent = CrewAgentWrapper()
+        except ImportError as e:
+            raise ImportError(f"Failed to import CrewAI agent_code: {e}")
+    
+    def predict(self, context, model_input):
+        if isinstance(model_input, list):
+            return [self.agent.run(query) for query in model_input]
+        else:
+            return self.agent.run(model_input)