solace-agent-mesh 0.2.4__py3-none-any.whl → 1.0.1__py3-none-any.whl

solace_agent_mesh/services/file_service/file_transformations.py

@@ -1,141 +0,0 @@
-import re
-import json
-import base64
-import zipfile
-import gzip
-import io
-
-from solace_ai_connector.common.log import log
-from .transformers import TRANSFORMERS
-
-QUERY_OPTIONS = {
-    "encoding": ["zip", "gzip", "base64", "datauri"],
-}
-
-for tr in TRANSFORMERS:
-    for key, value in tr.queries.items():
-        QUERY_OPTIONS[key] = value.get("type")
-
-LLM_QUERY_OPTIONS = {
-    **QUERY_OPTIONS,
-    "resolve": "bool",
-}
-
-
-def encode_file(file: bytes, encoding: str, mime_type: str, file_name=str) -> bytes:
-    """
-    Encode a file using the specified encoding.
-
-    Parameters:
-    - file (bytes): The file content as bytes.
-    - encoding (str): The encoding to use ('zip', 'gzip', 'base64', 'datauri').
-
-    Returns:
-    - bytes: The encoded file content.
-    """
-    try:
-        if encoding == "zip":
-            # Create a BytesIO buffer to hold the zip file
-            zip_buffer = io.BytesIO()
-            # Create a zip file in the buffer
-            with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zip_file:
-                # Add the file to the ZIP archive
-                zip_file.writestr(file_name, file)
-            # Get the byte buffer of the zip file
-            zip_buffer.seek(0)  # Move to the beginning of the buffer
-            return zip_buffer.read()
-
-        elif encoding == "gzip":
-            # Create a BytesIO buffer to hold the gzip file
-            gzip_buffer = io.BytesIO()
-            # Create a gzip file in the buffer
-            with gzip.GzipFile(fileobj=gzip_buffer, mode="wb") as gzip_file:
-                # Write the file content to the gzip archive
-                gzip_file.write(file)
-            return gzip_buffer.getvalue()
-
-        elif encoding == "base64":
-            return base64.b64encode(file).decode("utf-8")
-
-        elif encoding == "datauri":
-            return f"data:{mime_type};base64,{base64.b64encode(file).decode('utf-8')}"
-
-    except Exception as e:
-        log.error("Failed to encode file: %s", e)
-        return file
-
-    return file
-
-
-def apply_file_transformations(
-    file: bytes, metadata: dict, transformations: dict = {}
-) -> bytes | str:
-    """
-    Apply transformations to a file.
-
-    Parameters:
-    - file (bytes): The file content as bytes.
-    - metadata (dict): The file metadata.
-    - transformations (dict): The transformations to apply.
-    """
-    if not transformations:
-        return file
-    text_mime_type_regex = r"text/.*|.*csv|.*json|.*xml|.*yaml|.*x-yaml|.*txt"
-    mime_type = metadata.get("mime_type", "")
-    if mime_type is None:
-        mime_type = ""
-    name = metadata.get("name", "unknown")
-    other = {
-        "mime_type": mime_type,
-        "name": name,
-    }
-    data = file
-    if not re.match(text_mime_type_regex, mime_type):
-        for transformer in TRANSFORMERS:
-            if transformer.is_binary_transformer:
-                data = transformer.transform(file, data, transformations, other)                     
-
-        # Should be last transformation
-        if transformations.get("encoding"):
-            try:
-                byte_data = data if isinstance(data, bytes) else data.encode("utf-8")
-                return encode_file(
-                    byte_data, transformations.get("encoding"), mime_type, name
-                )
-            except Exception as e:
-                log.error("Failed to encode to base64: %s", e)
-                return file
-        return data
-    else:
-        # File is text-based
-        # Convert bytes to string if of type bytes
-        decoded_data = file.decode("utf-8") if isinstance(file, bytes) else file
-        data = decoded_data
-
-        for transformer in TRANSFORMERS:
-            if transformer.is_text_transformer:
-                data = transformer.transform(file, data, transformations, other)
-
-        # Should be last transformation
-        if transformations.get("encoding"):
-            try:
-                byte_data = data if isinstance(data, bytes) else data.encode("utf-8")
-                return encode_file(
-                    byte_data, transformations["encoding"], mime_type, name
-                )
-            except Exception as e:
-                log.error("Failed to encode to base64: %s", e)
-                return file
-
-        if not isinstance(data, str):
-            # Convert bytes to string
-            if isinstance(data, bytes):
-                try:
-                    data = data.decode("utf-8")
-                except UnicodeDecodeError:
-                    data = base64.b64encode(data).decode("utf-8")
-                    data = f"data:{mime_type};base64,{data}"
-            else:
-                data = json.dumps(data)
-
-        return data

solace_agent_mesh/services/file_service/file_utils.py

@@ -1,324 +0,0 @@
-# Add utility functions for upload CSV that automatically creates the number of row and data types
-import csv
-from typing import Tuple, Union
-import json
-
-from .file_service_constants import FS_PROTOCOL, INDENT_SIZE
-
-
-class Types:
-    """
-    Type constants definition to be used when representing the schema.
-    """
-
-    INT = "int"
-    FLOAT = "float"
-    BOOL = "bool"
-    STR = "str"
-    ARRAY = "array"
-    OBJECT = "object"
-    NULL = "null"
-
-    @property
-    def PRIMITIVES():
-        return [Types.INT, Types.FLOAT, Types.BOOL, Types.STR]
-
-
-def get_str_type(value: str) -> str:
-    """
-    Get the type of a string value.
-
-    Parameters:
-    - value (str): The string value.
-
-    Returns:
-    - str: The type of the value.
-    """
-    if not value:
-        return Types.NULL
-    if value.isdigit():
-        return Types.INT
-    elif value.replace(".", "", 1).isdigit():
-        return Types.FLOAT
-    else:
-        return Types.STR
-
-
-def convert_dict_to_yaml(schema: dict, indent_size=INDENT_SIZE, _level=0) -> str:
-    """
-    Convert a dictionary schema to a YAML string.
-
-    Parameters:
-    - schema (dict): The dictionary schema.
-
-    Returns:
-    - str: The YAML string.
-    """
-    yaml_str = ""
-    indent = indent_size * _level
-
-    for key, value in schema.items():
-        if isinstance(value, dict):
-            value_str = convert_dict_to_yaml(value, indent_size, _level + 1)
-            yaml_str += f"{space(indent)}{key}:\n{value_str}\n"
-        else:
-            yaml_str += f"{space(indent)}{key}: {value}\n"
-    return yaml_str.rstrip()
-
-
-def space(size=INDENT_SIZE):
-    """
-    Get a string of spaces.
-    """
-    if size == 0:
-        return ""
-    return " " * size
-
-
-def extract_csv_schema_and_shape(csv_file: Union[str, bytes]) -> Tuple[dict, Tuple[int, int]]:
-    """
-    Get the schema and shape of a CSV file.
-
-    Parameters:
-    - csv_file (str): The CSV file content.
-    - header_row (str): The header row of the CSV file.
-
-    Returns:
-    - str: The schema of the CSV file.
-    - st: The shape of the CSV file.
-    """
-    if type(csv_file) == bytes:
-        csv_file = csv_file.decode("utf-8")
-
-    # Parse the CSV string
-    csv_lines = csv_file.splitlines()
-    csv_reader = csv.DictReader(csv_lines)
-    columns = csv_reader.fieldnames
-    listed_csv = list(csv_reader)
-    shape = (len(listed_csv), len(columns))
-    schema = {}
-    for col in columns:
-        # deriving type from the top 10 rows
-        col_type = None
-        for i, row in enumerate(listed_csv):
-            if i >= 10:
-                break
-            curr_type = get_str_type(row[col])
-            if col_type is None:
-                col_type = curr_type
-            elif col_type != curr_type:
-                # multiple types, set as str
-                col_type = Types.STR
-                break
-        schema[col] = {"type": col_type}
-
-    return schema, shape
-
-
-def dict_to_schema(input_dict: dict) -> dict:
-    """
-    Convert a dictionary to a JSON schema.
-
-    Parameters:
-    - input_dict (dict): The input dictionary.
-
-    Returns:
-    - dict: The JSON schema.
-    """
-
-    def infer_type(value):
-        if isinstance(value, str):
-            return Types.STR
-        elif isinstance(value, int):
-            return Types.INT
-        elif isinstance(value, float):
-            return Types.FLOAT
-        elif isinstance(value, bool):
-            return Types.BOOL
-        elif isinstance(value, list):
-            if len(value) > 0:
-                return {"type": Types.ARRAY, "items": infer_type(value[0])}
-            else:
-                return {"type": Types.ARRAY, "items": {}}
-        elif isinstance(value, dict):
-            return {"type": Types.OBJECT, "properties": infer_properties(value)}
-        else:
-            return Types.NULL
-
-    def infer_properties(input_dict):
-        return {
-            key: (
-                {"type": infer_type(value)}
-                if isinstance(infer_type(value), str)
-                else infer_type(value)
-            )
-            for key, value in input_dict.items()
-        }
-
-    if type(input_dict) is list:
-        input_dict = input_dict[0]
-        json_schema = {
-            "type": Types.ARRAY,
-            "items": {"type": Types.OBJECT, "properties": infer_properties(input_dict)},
-        }
-    else:
-        json_schema = {"type": Types.OBJECT, "properties": infer_properties(input_dict)}
-
-    return json_schema
-
-
-def get_dict_array_shape(
-    data: Union[dict, list], max_level=2, _path="", _result=None, _level=0
-):
-    """
-    Get the count of each array in a dictionary schema.
-    """
-    if _result is None:
-        _result = []
-
-    # If it's a list, record its length and traverse each element
-    if isinstance(data, list):
-        if _path:
-            _result.append([_path, len(data)])
-        else:
-            _result.append(["top level", len(data)])
-        if _level < max_level:
-            get_dict_array_shape(data[0], max_level, f"{_path}[*]", _result, _level + 1)
-
-    # If it's a dictionary, traverse each key-value pair
-    elif isinstance(data, dict):
-        for key, value in data.items():
-            new_path = f"{_path}.{key}" if _path else key
-            if _level < max_level:
-                get_dict_array_shape(value, max_level, new_path, _result, _level + 1)
-
-    return _result
-
-
-def get_csv_schema_and_shape(schema: dict, shape: Tuple[int, int]) -> Tuple[str, str]:
-    """
-    Get the formatted schema and shape of a CSV file.
-
-    Parameters:
-    - schema (dict): The schema of the CSV file.
-    - shape (Tuple[int, int]): The shape of the CSV file.
-
-    Returns:
-    - str: The formatted schema of the CSV file.
-    - Tuple[int, int]: The shape of the CSV file.
-    """
-    shape_str = f"{shape[0]} rows x {shape[1]} columns"
-    schema_dict = {
-        "type": Types.ARRAY,
-        "items": {"type": Types.OBJECT, "properties": schema},
-    }
-    schema_str = convert_dict_to_yaml(schema_dict)
-    return schema_str, shape_str
-
-
-def get_json_schema_and_shape(file: Union[bytes, str]) -> Tuple[str, str]:
-    try:
-        if type(file) == bytes:
-            file = file.decode("utf-8")
-        json_data = json.loads(file)
-        schema = dict_to_schema(json_data)
-        schema_str = convert_dict_to_yaml(schema)
-        shape_str = None
-
-        def get_row_text(count):
-            return f"{count} elements" if count > 1 else f"{count} element"
-
-        array_lengths = get_dict_array_shape(json_data)
-        if array_lengths:
-            shape_str = "\n".join(
-                [f"{key}: {get_row_text(val)}" for key, val in array_lengths]
-            )
-        return schema_str, shape_str
-    except Exception as e:
-        return None, None
-
-
-def get_file_schema_and_shape(file: bytes, metadata: dict) -> Tuple[str, str]:
-    """
-    Get the schema and shape of a file.
-
-    Parameters:
-    - file (bytes): The file content as bytes.
-    - metadata (dict): The file metadata.
-
-    Returns:
-    - str: The schema of the file. None if cannot be determined.
-    - str: The shape of the file. None if cannot be determined.
-    """
-    if metadata.get("mime_type") == "text/csv":
-        schema, shape = extract_csv_schema_and_shape(file)
-        schema_str, shape_str = get_csv_schema_and_shape(schema, shape)
-        return schema_str, shape_str
-    elif metadata.get("mime_type") == "application/json":
-        schema, shape = get_json_schema_and_shape(file)
-        return schema, shape
-    else:
-        return None, None
-
-
-def recursive_file_resolver(
-    obj: Union[dict, str, list],
-    resolver: callable,
-    session_id: str,
-    force_resolve: bool = False,
-):
-    """
-    Recursively resolve all the file URLs in the input data.
-
-    Parameters:
-    - obj (dict|str|list): The input data.
-    - resolver (callable): The resolver function.
-    - session_id (str): The session ID.
-    - force_resolve (bool): Resolve all the URLs regardless of the 'resolve' query parameter.
-
-    Returns:
-    - dict|str|list: The object with resolved URLs.
-    """
-    if type(obj) == str:
-        return resolver(obj, session_id, force_resolve)
-
-    keys = []
-    if type(obj) == list:
-        keys = range(len(obj))
-    elif type(obj) == dict:
-        keys = obj.keys()
-
-    for key in keys:
-        if isinstance(obj[key], dict):
-            obj[key] = recursive_file_resolver(
-                obj[key], resolver, session_id, force_resolve
-            )
-        elif isinstance(obj[key], list):
-            obj[key] = [
-                (
-                    recursive_file_resolver(item, resolver, session_id, force_resolve)
-                    if isinstance(item, dict)
-                    else item
-                )
-                for item in obj[key]
-            ]
-        elif isinstance(obj[key], str):
-            obj[key] = resolver(obj[key], session_id, force_resolve)
-    return obj
-
-
-def starts_with_fs_url(url: str) -> bool:
-    """
-    Check if the URL starts with the file service protocol.
-
-    Parameters:
-    - url (str): The URL.
-
-    Returns:
-    - bool: True if the URL starts with the file service protocol.
-    """
-    return (
-        url.startswith(f"{FS_PROTOCOL}://")
-        or url.startswith(f"<url>{FS_PROTOCOL}://")
-        or url.startswith(f"<url> {FS_PROTOCOL}://")
-    )

solace_agent_mesh/services/file_service/transformers/__init__.py

@@ -1,5 +0,0 @@
-TRANSFORMERS = []
-
-__all__ = [
-    "TRANSFORMERS"
-]

solace_agent_mesh/services/history_service/__init__.py

@@ -1,3 +0,0 @@
-from .history_service import HistoryService
-
-__all__ = ["HistoryService"]

solace_agent_mesh/services/history_service/history_providers/base_history_provider.py

@@ -1,54 +0,0 @@
-from abc import ABC, abstractmethod
-
-class BaseHistoryProvider(ABC):
-
-    def __init__(self, config=None):
-        self.config = config or {}
-    
-    @abstractmethod
-    def get_all_sessions(self) -> list[str]:
-        """
-        Retrieve all session identifiers.
-        """
-        raise NotImplementedError("Method not implemented")
-
-    @abstractmethod
-    def get_session(self, session_id: str)->dict:
-        """
-        Retrieve the session .
-
-        :param session_id: The session identifier.
-        :return: The session metadata.
-        """
-        raise NotImplementedError("Method not implemented")
-    
-    @abstractmethod
-    def delete_session(self, session_id: str):
-        """
-        Delete the session.
-
-        :param session_id: The session identifier.
-        """
-        raise NotImplementedError("Method not implemented")
-    
-    @abstractmethod
-    def store_session(self, session_id: str, data: dict):
-        """
-        Store the session metadata.
-
-        :param session_id: The session identifier.
-        :param data: The session data to be stored.
-        """
-        raise NotImplementedError("Method not implemented")
-    
-
-    def update_session(self, session_id: str, data: dict):
-        """
-        Update data in the store using the partial data provided.
-
-        :param key: The key to update the data under.
-        :param data: The data to update.
-        """
-        history = self.get_session(session_id).copy()
-        history.update(data)
-        self.store_session(session_id, history)

solace_agent_mesh/services/history_service/history_providers/file_history_provider.py

@@ -1,74 +0,0 @@
-import json
-import os
-from .base_history_provider import BaseHistoryProvider
-
-class FileHistoryProvider(BaseHistoryProvider):
-    """
-    A simple file-based history provider for storing session data.
-    """
-    def __init__(self, config=None):
-        super().__init__(config)
-
-        if not self.config.get("path"):
-            raise ValueError("Missing required configuration for FileHistoryProvider, Missing 'path' in configs.")
-        
-        self.path = self.config.get("path")
-
-        if not self._exists(self.path):
-            os.makedirs(self.path, exist_ok=True)
-
-    def _get_key(self, session_id):
-        """
-        Generate a file path for a session.
-
-        :param session_id: The session identifier.
-        :return: A formatted file path.
-        """
-        return os.path.join(self.path, f"sessions_{session_id}_history.json")
-
-    def store_session(self, session_id: str, data: dict):
-        """
-        Store the session metadata.
-
-        :param session_id: The session identifier.
-        :param data: The session data to be stored.
-        """
-        file_path = self._get_key(session_id)
-        with open(file_path, "w", encoding="utf-8") as f:
-            f.write(json.dumps(data))
-
-    def get_session(self, session_id: str)->dict:
-        """
-        Retrieve the session.
-
-        :param session_id: The session identifier.
-        :return: The session metadata as a dictionary.
-        """
-        file_path = self._get_key(session_id)
-        if not self._exists(file_path):
-            return {}
-        
-        try:
-            with open(file_path, "r", encoding="utf-8") as f:
-                return json.load(f)
-        except json.JSONDecodeError:
-            return {}
-
-    def get_all_sessions(self) -> list[str]:
-        """
-        Retrieve all session identifiers.
-        """
-        return [f[9:-13] for f in os.listdir(self.path) if f.startswith("sessions_") and f.endswith("_history.json")]
-    
-    def delete_session(self, session_id: str):
-        """
-        Delete the session.
-
-        :param session_id: The session identifier.
-        """
-        file_path = self._get_key(session_id)
-        if self._exists(file_path):
-            os.remove(file_path)
-
-    def _exists(self, path: str):
-        return os.path.exists(path)

solace_agent_mesh/services/history_service/history_providers/index.py

@@ -1,40 +0,0 @@
-
-
-class HistoryProviderFactory:
-    """
-    Factory class for creating history provider instances.
-    """
-    HISTORY_PROVIDERS = ["redis", "memory", "file", "mongodb", "sql"]
-
-    @staticmethod
-    def has_provider(class_name):
-        """
-        Check if the history provider is supported.
-        """
-        return class_name in HistoryProviderFactory.HISTORY_PROVIDERS
-
-    @staticmethod
-    def get_provider_class(class_name):
-        """
-        Get the history provider class based on the class name.
-        """
-        if class_name not in HistoryProviderFactory.HISTORY_PROVIDERS:
-            raise ValueError(f"Unsupported history provider: {class_name}")
-        if class_name == "redis":
-            from .redis_history_provider import RedisHistoryProvider
-            return RedisHistoryProvider
-        elif class_name == "memory":
-            from .memory_history_provider import MemoryHistoryProvider
-            return MemoryHistoryProvider
-        elif class_name == "file":
-            from .file_history_provider import FileHistoryProvider
-            return FileHistoryProvider
-        elif class_name == "mongodb":
-            from .mongodb_history_provider import MongoDBHistoryProvider
-            return MongoDBHistoryProvider
-        elif class_name == "sql":
-            from .sql_history_provider import SQLHistoryProvider
-            return SQLHistoryProvider
-        else:
-            raise ValueError(f"Unsupported history provider: {class_name}")
-

solace_agent_mesh/services/history_service/history_providers/memory_history_provider.py

@@ -1,33 +0,0 @@
-"""
-Memory history provider
-"""
-
-from .base_history_provider import BaseHistoryProvider
-
-
-class MemoryHistoryProvider(BaseHistoryProvider):
-    """
-    A history provider that stores history in memory.
-    """
-
-    def __init__(self, config=None):
-        super().__init__(config)
-        self.history = {}
-
-    def store_session(self, session_id, data):
-        if session_id not in self.history:
-            self.history[session_id] = {}
-        
-        self.history[session_id].update(data)
-
-    def get_session(self, session_id):
-        if session_id not in self.history:
-            return {}
-        return self.history[session_id]
-
-    def get_all_sessions(self) -> list[str]:
-        return list(self.history.keys())
-
-    def delete_session(self, session_id):
-        if session_id in self.history:
-            del self.history[session_id]