fairo 25.5.4__tar.gz → 25.6.2__tar.gz

{fairo-25.5.4 → fairo-25.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fairo
-Version: 25.5.4
+Version: 25.6.2
 Summary: SDK for interfacing with Fairo SaaS platform.
 Author-email: "Fairo Systems, Inc." <support@fairo.ai>
 License: Apache-2.0

{fairo-25.5.4 → fairo-25.6.2}/fairo/core/agent/base_agent.py

@@ -8,12 +8,12 @@ import sys
 from typing import Dict, List, Optional, Callable, Any, Tuple
 from langchain.schema import HumanMessage, AIMessage, SystemMessage
 from langchain_core.messages import ToolMessage
-from langchain_community.chat_models.mlflow import ChatMlflow
 from langchain_core.runnables.config import RunnableConfig
 from fairo.core.agent.output.base_output import BaseOutput
 from fairo.core.agent.tools.base_tools import BaseTool
 from fairo.core.agent.tools.utils import Iteration, LLMAgentOutput, ToolResult
 from langchain_core.messages.tool import ToolCall
+from fairo.core.chat.chat import FairoChat
 from fairo.core.client.client import BaseClient
 from fairo.core.workflow.dependency import BaseVectorStore
 from fairo.core.agent.utils import truncate_content, truncate_obj_content
@@ -66,10 +66,9 @@ class SimpleAgent:
         self.verbose = verbose
         self.use_langchain_mlflow_chat = True if not llm else False
         self.workflow_run_id = workflow_run_id
-        self.llm = llm or ChatMlflow(
-            target_uri=get_mlflow_gateway_uri(),
+        self.llm = llm or FairoChat(
             endpoint=get_mlflow_gateway_chat_route(),
-            extra_params={"workflow_run_id": self.workflow_run_id}
+            workflow_run_id=self.workflow_run_id
         )
         self.memory = memory or []
         self.conversation_history = []
@@ -782,12 +781,12 @@ class SimpleAgent:
             output.add_duration(f"{total_execution_time:.2f}s")
 
             # Save output
-            if self.patch_run_output_json:
-                self.patch_run_output_json(output.to_dict())
+            # if self.patch_run_output_json:
+            #     self.patch_run_output_json(output.to_dict())
 
             # Execute output
-            if self.output and len(self.output) > 0:
-                self.execute_outputs(final_answer)
+            # if self.output and len(self.output) > 0:
+            #     self.execute_outputs(final_answer)
 
             return final_answer
 
@@ -823,8 +822,8 @@ class SimpleAgent:
             output.add_duration(f"{total_execution_time:.2f}s")
 
             # Make sure to patch the output with the error
-            if self.patch_run_output_json:
-                self.patch_run_output_json(output.to_dict())
+            # if self.patch_run_output_json:
+            #     self.patch_run_output_json(output.to_dict())
 
             # Re-throw the exception with more context
             raise Exception(f"Agent execution failed: {error_msg}") from e
@@ -855,22 +854,22 @@ class SimpleAgent:
                 output_errors.append((error_msg, traceback_details))
 
         # Report errors after processing all outputs to avoid multiple error records for the same run
-        if output_errors and self.patch_run_output_json:
-            # Create a single error output object with all errors
-            error_output = LLMAgentOutput(
-                node_name=self.agent_name,
-                task="Output execution",
-                context=None,
-                query_result=None,
-                memory=None
-            )
-
-            # Add all collected errors
-            for error_msg, traceback_details in output_errors:
-                error_output.add_error(error_msg, traceback_details)
-
-            # Patch once with all errors
-            self.patch_run_output_json(error_output.to_dict())
+        # if output_errors and self.patch_run_output_json:
+        #     # Create a single error output object with all errors
+        #     error_output = LLMAgentOutput(
+        #         node_name=self.agent_name,
+        #         task="Output execution",
+        #         context=None,
+        #         query_result=None,
+        #         memory=None
+        #     )
+
+        #     # Add all collected errors
+        #     for error_msg, traceback_details in output_errors:
+        #         error_output.add_error(error_msg, traceback_details)
+
+        #     # Patch once with all errors
+        #     self.patch_run_output_json(error_output.to_dict())
 
     def add_memory(self, content: str) -> None:
         """

fairo-25.6.2/fairo/core/chat/chat.py

@@ -0,0 +1,23 @@
+
+from langchain_community.chat_models.mlflow import ChatMlflow
+from mlflow.deployments import get_deploy_client
+import os
+
+class FairoChat(ChatMlflow):
+    def __init__(self, endpoint, workflow_run_id, **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.6.2/fairo/core/execution/env_finder.py

@@ -0,0 +1,46 @@
+import os
+import re
+import mlflow
+
+ENV_PATTERNS = [
+    re.compile(r"os\.getenv\(\s*[\"'](\w+)[\"']"),                # os.getenv("VAR")
+    re.compile(r"os\.environ\.get\(\s*[\"'](\w+)[\"']"),           # os.environ.get("VAR")
+    re.compile(r"os\.environ\[\s*[\"'](\w+)[\"']\s*\]"),           # os.environ["VAR"]
+]
+
+def find_env_vars_in_file(file_path):
+    found_vars = set()
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            content = f.read()
+            for pattern in ENV_PATTERNS:
+                found_vars.update(pattern.findall(content))
+    except (UnicodeDecodeError, OSError):
+        pass  # Skip unreadable files
+    return found_vars
+
+def recursively_find_env_vars(start_path, exclude_dirs=None):
+    if exclude_dirs is None:
+        exclude_dirs = {"venv", ".venv", "__pycache__", ".git", ".mypy_cache", ".pytest_cache", "site-packages"}
+
+    all_vars = set()
+    for root, dirs, files in os.walk(start_path):
+        # Skip excluded directories
+        dirs[:] = [d for d in dirs if d not in exclude_dirs and not d.startswith(".")]
+
+        for file in files:
+            if file.endswith(".py"):
+                full_path = os.path.join(root, file)
+                file_vars = find_env_vars_in_file(full_path)
+                if file_vars:
+                    print(f"Found in {full_path}: {file_vars}")
+                    all_vars.update(file_vars)
+    return all_vars
+
+def read_variables() -> str:
+    current_path = os.getcwd()
+    env_vars = recursively_find_env_vars(current_path)
+    logged_vars = ""
+    for var in env_vars:
+        logged_vars += f"{var}\n"
+    return logged_vars

{fairo-25.5.4 → fairo-25.6.2}/fairo/core/execution/executor.py

@@ -1,42 +1,55 @@
+import json
+import os
 import types
 from typing import List, Any, Callable, Dict, Union
 from langchain_core.runnables import RunnableLambda, RunnableSequence
 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.env_finder import read_variables
+from fairo.core.runnable.runnable import Runnable
+from fairo.core.workflow.utils import output_workflow_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
 
-class BaseClient:
-    pass
-
 logger = logging.getLogger(__name__)
 
-class AgentExecutor:
+class FairoExecutor:
     def __init__(
         self,
         agents: List[Any],
         verbose: bool = False,
         patch_run_output_json: Callable[[LLMAgentOutput], None] = None,
-        client: BaseClient = None,
-        workflow_run_id: str = ""
+        workflow_run_id: str = "",
+        runnable: Runnable = None,
+        experiment_name: str = None
     ):
         self.agents = agents
         self.verbose = verbose
         self.patch_run_output_json = patch_run_output_json
-        self.client = client
         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.client = BaseClient(
+            base_url=get_fairo_base_url(),
+            password=get_fairo_api_secret(),
+            username=get_fairo_api_key()
+        )
         # Inject shared attributes into agents
         for agent in self.agents:
-            if hasattr(agent, 'patch_run_output_json'):
-                agent.patch_run_output_json = self.patch_run_output_json
             if hasattr(agent, 'set_client'):
                 agent.set_client(self.client)
             if hasattr(agent, 'verbose'):
                 agent.verbose = self.verbose
-            if hasattr(agent, 'workflow_run_id'):
-                agent.set_workflow_run_id(self.workflow_run_id)
 
         self.pipeline = self._build_pipeline()
 
@@ -86,12 +99,72 @@ class AgentExecutor:
             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
-
+        
+        def save_process_graph():
+            process_graph = (
+                output_workflow_process_graph(self.agents)
+                if all(isinstance(agent, SimpleAgent) for agent in self.agents)
+                else None
+            )
+            if len(self.agents) > 1:
+                type = "Workflow"
+            else:
+                type = "Agent"
+            fairo_settings = {
+                "type": type,
+                "process_graph": process_graph,
+            }
+            if process_graph:
+                mlflow.log_text(json.dumps(fairo_settings, ensure_ascii=False, indent=2), artifact_file="fairo_settings.txt")
+        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)}")
+
+        input_schema = Schema([
+            ColSpec(type="string", name=first_input_key),
+        ])
+
+        output_schema = Schema([
+            ColSpec(type="string", name=last_output_key),
+        ])
+        model_info = mlflow.langchain.log_model(
+            pipeline,
+            artifact_path="",
+            signature=ModelSignature(inputs=input_schema, outputs=output_schema)
+        )
+        # If runnable object was added, check if it exists, if yes, just set tags for the trace, otherwise create it
+        if self.runnable:
+            if not self.runnable.id:
+                result = mlflow.register_model(
+                    model_uri=model_info.model_uri,
+                    name=self.runnable.name,
+                    await_registration_for=0
+                )
+                self.runnable.create_version(
+                    artifact_path=result.source,
+                    registered_model_id=f"models:/{self.runnable.name}/{result.version}"
+                )
+            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]:
@@ -127,4 +200,23 @@ class AgentExecutor:
                 logger.error(f"Pipeline execution failed: {str(e)}")
             
             # Propagate the exception so calling code can handle it
-            raise
+            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()
+        with mlflow.start_run():
+            mlflow.langchain.autolog(
+                log_traces=True,
+                log_input_examples=True,
+            )
+        

fairo-25.6.2/fairo/core/runnable/runnable.py

@@ -0,0 +1,77 @@
+from typing import Any, List, Literal, Optional
+
+from fairo.core.agent.base_agent import SimpleAgent
+from fairo.core.client.client import BaseClient
+from fairo.core.workflow.utils import output_workflow_process_graph
+from fairo.settings import get_fairo_base_url, get_fairo_api_key, get_fairo_api_secret
+
+class Runnable:
+    def __init__(self,
+                 name: str,
+                 version: int,
+                 type: Literal["Agent", "Workflow", "Default"],
+                 chain: List[Any] = [],
+                 agent: Optional[SimpleAgent] = None,
+                 artifact_path: Optional[str] = None,
+                 description: Optional[str] = ""):
+        self.id = None
+        self.process_graph = None
+        self.name = name
+        self.version = version
+        self.type = type
+        self.chain = chain
+        self.agent = agent
+        self.artifact_path = artifact_path
+        self.description = description
+        self.client = BaseClient(
+            base_url=get_fairo_base_url(), 
+            username=get_fairo_api_key(), 
+            password=get_fairo_api_secret()
+        )
+        
+        self.load_version()
+        
+    
+    def load_version(self):
+        try:
+            response = self.client.get(f"/runnables?version={self.version}&name={self.name}&page_size=1")
+            if len(response.get('results')) > 0:
+                runnable_obj = response.get('results')[0]
+                self.artifact_path = runnable_obj.get('artifact_path')
+                self.type = runnable_obj.get('type')
+                self.description = runnable_obj.get('description')
+                self.id = runnable_obj.get('id')
+                self.process_graph = runnable_obj.get('process_graph')
+        except Exception as e:
+            print("Failed to check existing runnable version")
+            raise e
+    
+    def create_version(self, artifact_path, registered_model_id):
+        try:
+            process_graph = output_workflow_process_graph(self.chain) if all(isinstance(agent, SimpleAgent) for agent in self.chain) else None
+            payload = {
+                "name": self.name,
+                "version": self.version,
+                "artifact_path": artifact_path,
+                "description": self.description,
+                "type": self.type,
+                "registered_model_id": registered_model_id,
+                "process_graph": process_graph
+            }
+            response = self.client.post(f"/runnables", json=payload)
+            self.id = response.get('id')
+            self.process_graph = response.get('process_graph')
+        except Exception as e:
+            print("Failed to create runnable version")
+            raise e
+        
+    def patch_process_graph(self):
+        try:
+            process_graph = output_workflow_process_graph(self.chain)
+            response = self.client.patch(f"/runnables/{self.id}", json={
+                "process_graph": process_graph
+            }, auth=(self.api_key, self.api_secret))
+            return response.json()
+        except Exception as e:
+            print(e)
+            

{fairo-25.5.4 → fairo-25.6.2}/fairo/core/workflow/base_workflow.py

@@ -8,7 +8,8 @@ from fairo.core.agent.base_agent import SimpleAgent
 from fairo.core.agent.tools.utils import FlowOutput, LLMAgentOutput
 from fairo.core.client.client import BaseClient
 
-from fairo.core.execution.executor import AgentExecutor
+from fairo.core.execution.executor import FairoExecutor
+from fairo.core.runnable.runnable import Runnable
 from fairo.core.workflow.utils import output_workflow_process_graph
 from fairo.settings import (
     get_fairo_api_key, 
@@ -219,7 +220,7 @@ class BaseWorkflow:
         Propagates any exceptions from agents.
         """
         client = BaseClient(base_url=self.base_url, username=self.api_key, password=self.api_secret)
-        executor = AgentExecutor(
+        executor = FairoExecutor(
             agents=self.agents,
             verbose=False,
             patch_run_output_json=self.add_workflow_run_node_output,

{fairo-25.5.4 → fairo-25.6.2}/fairo/settings.py

@@ -54,6 +54,8 @@ def get_mlflow_token():
 def get_mlflow_experiment_path():
     return os.getenv('MLFLOW_EXPERIMENT_PATH', None)
 
+def get_mlflow_experiment_name():
+    return os.getenv('MLFLOW_EXPERIMENT_NAME', "Development Default")
 
 def get_use_databricks_tracking_server():
     return os.getenv('USE_DATABRICKS_TRACKING_SERVER', False)

{fairo-25.5.4 → fairo-25.6.2}/fairo.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fairo
-Version: 25.5.4
+Version: 25.6.2
 Summary: SDK for interfacing with Fairo SaaS platform.
 Author-email: "Fairo Systems, Inc." <support@fairo.ai>
 License: Apache-2.0

{fairo-25.5.4 → fairo-25.6.2}/fairo.egg-info/SOURCES.txt

@@ -20,13 +20,18 @@ fairo/core/agent/tools/__init__.py
 fairo/core/agent/tools/base_tools.py
 fairo/core/agent/tools/code_analysis.py
 fairo/core/agent/tools/utils.py
+fairo/core/chat/__init__.py
+fairo/core/chat/chat.py
 fairo/core/client/__init__.py
 fairo/core/client/client.py
 fairo/core/execution/__init__.py
+fairo/core/execution/env_finder.py
 fairo/core/execution/executor.py
 fairo/core/models/__init__.py
 fairo/core/models/custom_field_value.py
 fairo/core/models/resources.py
+fairo/core/runnable/__init__.py
+fairo/core/runnable/runnable.py
 fairo/core/workflow/__init__.py
 fairo/core/workflow/base_workflow.py
 fairo/core/workflow/dependency.py