fairo 25.6.5__tar.gz → 25.7.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fairo
-Version: 25.6.5
+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,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.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.6.5 → fairo-25.7.1}/fairo/core/execution/executor.py

@@ -1,51 +1,57 @@
 import json
 import os
-import types
 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.agent.base_agent import SimpleAgent
 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_workflow_process_graph
+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
 
-# Optional interfaces/types
-class LLMAgentOutput:
-    pass
 
 logger = logging.getLogger(__name__)
 
 class FairoExecutor:
     def __init__(
         self,
+        agent_type: str = "Langchain",
         agents: List[Any] = [],
         verbose: bool = False,
-        patch_run_output_json: Callable[[LLMAgentOutput], None] = None,
+        patch_run_output_json: Callable[[Any], None] = None,
         workflow_run_id: str = "",
         runnable: Runnable = None,
-        experiment_name: str = 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'):
@@ -53,81 +59,31 @@ class FairoExecutor:
             if hasattr(agent, 'verbose'):
                 agent.verbose = self.verbose
 
-        self.pipeline = self._build_pipeline()
-
-    def _wrap_agent_runnable(self, agent, input_key: str, output_key: str) -> 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]:
-            if self.verbose:
-                logger.info(f"[{agent.__class__.__name__}] received input: {inputs}")
-            
-            # Run the agent, but don't catch exceptions - let them propagate
-            # This will stop the entire pipeline on agent failure
-            result = agent.run(inputs[input_key])
-            
-            # 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 {output_key: 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 _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.langchain.load_model(self.runnable.artifact_path)
-
-        # Assign input/output keys
-        if len(self.agents) > 0:
-            for i, agent in enumerate(self.agents):
-                agent.input_key = "input" if i == 0 else f"output_{i - 1}"
-                agent.output_key = f"output_{i}"
-
-            runnables = []
-            for agent in self.agents:
-                runnables.append(
-                    self._wrap_agent_runnable(agent, agent.input_key, agent.output_key)
-                )
-            first_input_key = self.agents[0].input_key
-            last_output_key = self.agents[-1].output_key
-            # Build RunnableSequence from all steps
-            pipeline = runnables[0]
-            for r in runnables[1:]:
-                pipeline = pipeline | r  # chaining
-            
-            input_schema = Schema([
-                ColSpec(type="string", name=first_input_key),
-            ])
+            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=last_output_key),
+                ColSpec(type="string", name="output"),
             ])
-            model_info = mlflow.langchain.log_model(
-                pipeline,
-                artifact_path="",
-                signature=ModelSignature(inputs=input_schema, outputs=output_schema)
-            )
+            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_workflow_process_graph(self.agents)
+                process_graph = output_langchain_process_graph([ag() for ag in self.agents])
                 if len(self.agents) > 1:
                     type = "Workflow"
                 else:
@@ -141,11 +97,16 @@ class FairoExecutor:
             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:
-            save_process_graph()
+            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()
@@ -173,30 +134,28 @@ class FairoExecutor:
         Execute the pipeline using the provided input.
         Properly handles and propagates errors from agents.
         """
-        if self.agents:
-            first_input_key = getattr(self.agents[0], 'input_key', 'input')
-        else:
-            first_input_key = 'input'
-
-        # Normalize input
-        if isinstance(input_data, str):
-            input_data = {first_input_key: input_data}
-        elif self.agents and (first_input_key not in input_data):
-            raise ValueError(f"Missing required input key: '{first_input_key}'")
-
         if self.verbose:
             logger.info("Running agent pipeline...")
             logger.info(f"Initial input: {input_data}")
 
         try:
             # Run the pipeline but don't catch exceptions
-            result = self.pipeline.invoke(input_data)
-            
-            if self.verbose:
-                logger.info("Pipeline execution completed")
-                logger.info(f"Final output: {result}")
+            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)
                 
-            return result
+                if self.verbose:
+                    logger.info("Pipeline execution completed")
+                    logger.info(f"Final output: {result}")
+                    
+                return result
             
         except Exception as e:
             # Log the error
@@ -217,10 +176,4 @@ class FairoExecutor:
             mlflow.set_tracking_uri(get_mlflow_server())
             mlflow.set_experiment(experiment_name=self.experiment_name)
         _clean_mlflow_env_vars()
-        setup_mlflow_tracking_server()
-        with mlflow.start_run():
-            mlflow.langchain.autolog(
-                log_traces=True,
-                log_input_examples=True,
-            )
-        
+        setup_mlflow_tracking_server()