fairo 25.6.4__tar.gz → 25.7.1__tar.gz

{fairo-25.6.4 → fairo-25.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fairo
-Version: 25.6.4
+Version: 25.7.1
 Summary: SDK for interfacing with Fairo SaaS platform.
 Author-email: "Fairo Systems, Inc." <support@fairo.ai>
 License: Apache-2.0
@@ -11,14 +11,16 @@ 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==2.21.2
-Requires-Dist: langchain==0.3.21
-Requires-Dist: langchain-aws==0.2.18
-Requires-Dist: langchain-community==0.3.20
-Requires-Dist: langchain-core==0.3.49
-Requires-Dist: langchain-text-splitters==0.3.7
-Requires-Dist: psycopg2-binary==2.9.10
-Requires-Dist: langchain-postgres==0.0.3
+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
+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.1/fairo/__init__.py

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

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

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

fairo-25.7.1/fairo/core/chat/chat.py

@@ -0,0 +1,54 @@
+
+from langchain_community.chat_models.mlflow import ChatMlflow
+from mlflow.deployments import get_deploy_client
+from fairo.settings import get_mlflow_gateway_chat_route, get_mlflow_gateway_uri, get_mlflow_user, get_mlflow_password
+import os
+
+
+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
+        )
+
+    @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 = get_deploy_client(self.target_uri)
+        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.1/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)

fairo-25.7.1/fairo/core/execution/executor.py

@@ -0,0 +1,179 @@
+import json
+import os
+from typing import List, Any, Callable, Dict, Union
+from langchain_core.runnables import RunnableLambda, RunnableSequence
+from langchain.chains import SimpleSequentialChain
+import logging
+
+import mlflow
+
+from mlflow.models.signature import ModelSignature
+from mlflow.types.schema import Schema, ColSpec
+from fairo.core.client.client import BaseClient
+from fairo.core.execution.agent_serializer import AgentChainWrapper
+from fairo.core.execution.env_finder import read_variables
+from fairo.core.execution.model_log_helper import ModelLogHelper
+from fairo.core.runnable.runnable import Runnable
+from fairo.core.workflow.utils import output_langchain_process_graph
+from fairo.settings import get_fairo_api_key, get_fairo_api_secret, get_mlflow_experiment_name, get_mlflow_server, get_fairo_base_url
+
+
+logger = logging.getLogger(__name__)
+
+class FairoExecutor:
+    def __init__(
+        self,
+        agent_type: str = "Langchain",
+        agents: List[Any] = [],
+        verbose: bool = False,
+        patch_run_output_json: Callable[[Any], None] = None,
+        workflow_run_id: str = "",
+        runnable: Runnable = None,
+        experiment_name: str = None,
+        chain_class = SimpleSequentialChain,
+        input_fields: List[str] = [],
+    ):
+        if agents and runnable:
+            raise ValueError("FairoExecutor cannot be initialized with both 'agents' and 'runnable'. Please provide only one.")
+        if not input_fields:
+            raise ValueError("Missing input_fields")
+        self.agents = agents
+        self.agent_type = agent_type
+        self.verbose = verbose
+        self.patch_run_output_json = patch_run_output_json
+        self.workflow_run_id = workflow_run_id
+        self.runnable = runnable
+        self.experiment_name = experiment_name if experiment_name else get_mlflow_experiment_name()
+        self.setup_mlflow()
+        self.chain_class = chain_class
+        self.client = BaseClient(
+            base_url=get_fairo_base_url(),
+            password=get_fairo_api_secret(),
+            username=get_fairo_api_key()
+        )
+        self.input_fields = input_fields
+        # Inject shared attributes into agents
+        for agent in self.agents:
+            if hasattr(agent, 'set_client'):
+                agent.set_client(self.client)
+            if hasattr(agent, 'verbose'):
+                agent.verbose = self.verbose
+
+    def _build_pipeline(self) -> RunnableSequence:
+        if not self.agents and not self.runnable:
+            raise ValueError("At least one agent or runnable must be provided.")
+        
+        if self.runnable:
+            pipeline = mlflow.pyfunc.load_model(self.runnable.artifact_path)
+        else:
+            pipeline = AgentChainWrapper(chain_class=self.chain_class, agent_functions_list=self.agents)
+            cols = [ColSpec(type="string", name=field) for field in self.input_fields]
+            input_schema = Schema(cols)
+
+            output_schema = Schema([
+                ColSpec(type="string", name="output"),
+            ])
+            current_run = mlflow.active_run()
+            # Log Model
+            ModelLogHelper(
+                agent_type=self.agent_type,
+                signature=ModelSignature(inputs=input_schema, outputs=output_schema),
+                agents=self.agents,
+            ).log_model()
+            
+        def save_process_graph():
+            if len(self.agents) > 0:
+                process_graph = output_langchain_process_graph([ag() for ag in self.agents])
+                if len(self.agents) > 1:
+                    type = "Workflow"
+                else:
+                    type = "Agent"
+            elif self.runnable:
+                process_graph = self.runnable.process_graph
+                type = self.runnable.type
+            else:
+                process_graph = None
+                type = None
+            fairo_settings = {
+                "type": type,
+                "process_graph": process_graph,
+                "input_schema": self.input_fields
+            }
+            if process_graph:
+                mlflow.log_text(json.dumps(fairo_settings, ensure_ascii=False, indent=2), artifact_file="fairo_settings.txt")
+        
+        if self.agents:
+            try:
+                save_process_graph()
+            except Exception as e:
+                logger.warning("It wasn't possible to generate and save process graph")
+        try:
+            # Find environment variables used in the project
+            all_env_vars = read_variables()
+            # Log the file as an artifact
+            mlflow.log_text(all_env_vars, artifact_file="environment/variables.txt")
+            if self.verbose:
+                logger.info(f"Logged {len(all_env_vars)} environment variables as artifact")
+        except Exception as e:
+            logger.warning(f"Failed to log environment variables: {str(e)}")
+
+        # If runnable object was added, set runnable_id tag for the trace
+        if self.runnable:
+            mlflow.set_tags({
+                "runnable_id": self.runnable.id,
+                "environment": "development",
+            })
+        else:
+            mlflow.set_tags({
+                "environment": "development",
+            })   
+        return pipeline
+
+    def run(self, input_data: Union[str, Dict[str, str]]) -> Dict[str, Any]:
+        """
+        Execute the pipeline using the provided input.
+        Properly handles and propagates errors from agents.
+        """
+        if self.verbose:
+            logger.info("Running agent pipeline...")
+            logger.info(f"Initial input: {input_data}")
+
+        try:
+            # Run the pipeline but don't catch exceptions
+            with mlflow.start_run() as run:
+                mlflow.autolog(
+                    log_traces=True,
+                    log_input_examples=True,
+                )
+                self.pipeline = self._build_pipeline()
+                if self.runnable:
+                    result = self.pipeline.predict(input_data)
+                else:
+                    result = self.pipeline.predict(model_input=input_data)
+                
+                if self.verbose:
+                    logger.info("Pipeline execution completed")
+                    logger.info(f"Final output: {result}")
+                    
+                return result
+            
+        except Exception as e:
+            # Log the error
+            if self.verbose:
+                logger.error(f"Pipeline execution failed: {str(e)}")
+            
+            # Propagate the exception so calling code can handle it
+            raise e
+    
+    def setup_mlflow(self):
+        def _clean_mlflow_env_vars():
+            for env_var in ["MLFLOW_TRACKING_USERNAME", "MLFLOW_TRACKING_PASSWORD", "MLFLOW_TRACKING_TOKEN"]:
+                if env_var in os.environ:
+                    del os.environ[env_var]
+        def setup_mlflow_tracking_server():
+            os.environ["MLFLOW_TRACKING_USERNAME"] = get_fairo_api_key()
+            os.environ["MLFLOW_TRACKING_PASSWORD"] = get_fairo_api_secret()
+            mlflow.set_tracking_uri(get_mlflow_server())
+            mlflow.set_experiment(experiment_name=self.experiment_name)
+        _clean_mlflow_env_vars()
+        setup_mlflow_tracking_server()