blaxel 0.64.0__py3-none-any.whl

blaxel/common/logger.py

@@ -0,0 +1,60 @@
+"""
+This module provides a custom colored formatter for logging and an initialization function
+to set up logging configurations for Blaxel applications.
+"""
+
+import logging
+
+
+class ColoredFormatter(logging.Formatter):
+    """
+    A custom logging formatter that adds ANSI color codes to log levels for enhanced readability.
+
+    Attributes:
+        COLORS (dict): A mapping of log level names to their corresponding ANSI color codes.
+    """
+    COLORS = {
+        "DEBUG": "\033[1;36m",  # Cyan
+        "INFO": "\033[1;32m",  # Green
+        "WARNING": "\033[1;33m",  # Yellow
+        "ERROR": "\033[1;31m",  # Red
+        "CRITICAL": "\033[1;41m",  # Red background
+    }
+
+    def format(self, record):
+        """
+        Formats the log record by adding color codes based on the log level.
+
+        Parameters:
+            record (LogRecord): The log record to format.
+
+        Returns:
+            str: The formatted log message with appropriate color codes.
+        """
+        n_spaces = len("CRITICAL") - len(record.levelname)
+        tab = " " * n_spaces
+        color = self.COLORS.get(record.levelname, "\033[0m")
+        record.levelname = f"{color}{record.levelname}\033[0m:{tab}"
+        return super().format(record)
+
+
+def init(log_level: str):
+    """
+    Initializes the logging configuration for Blaxel.
+
+    This function clears existing handlers for specific loggers, sets up a colored formatter,
+    and configures the root logger with the specified log level.
+
+    Parameters:
+        log_level (str): The logging level to set (e.g., "DEBUG", "INFO").
+    """
+    logging.getLogger("uvicorn.access").handlers.clear()
+    logging.getLogger("uvicorn.access").propagate = False
+    logging.getLogger("uvicorn.error").handlers.clear()
+    logging.getLogger("uvicorn.error").propagate = False
+    logging.getLogger("httpx").handlers.clear()
+    logging.getLogger("httpx").propagate = False
+
+    handler = logging.StreamHandler()
+    handler.setFormatter(ColoredFormatter("%(levelname)s %(name)s - %(message)s"))
+    logging.basicConfig(level=log_level, handlers=[handler])

blaxel/common/secrets.py

@@ -0,0 +1,39 @@
+import os
+
+
+class Secret:
+    """
+    A utility class for managing environment secrets.
+
+    Provides static methods to retrieve and set secret values, supporting both standard and
+    prefixed environment variable naming conventions.
+    """
+
+    @staticmethod
+    def get(name: str):
+        """
+        Retrieves the value of a secret environment variable.
+
+        This method first attempts to get the value using the standard name. If not found,
+        it tries with a "bl_" prefix.
+
+        Parameters:
+            name (str): The name of the environment variable to retrieve.
+
+        Returns:
+            str: The value of the environment variable if found, otherwise an empty string.
+        """
+        return os.getenv(name, os.getenv(f"bl_{name}"))
+
+    @staticmethod
+    def set(name: str, value: str):
+        """
+        Sets the value of a secret environment variable.
+
+        This method sets the value using the standard name, allowing for consistent secret management.
+
+        Parameters:
+            name (str): The name of the environment variable to set.
+            value (str): The value to assign to the environment variable.
+        """
+        os.environ[name] = value

blaxel/common/settings.py

@@ -0,0 +1,150 @@
+"""
+This module defines the configuration management system for Blaxel applications using Pydantic.
+It includes dataclasses for various configuration aspects, such as agents, authentication, and server settings.
+The module provides functions to initialize settings, load configurations from YAML files, and customize settings sources.
+"""
+
+import os
+from typing import Tuple, Type, Union
+
+from langchain_core.language_models.chat_models import BaseChatModel
+from langgraph.graph.graph import CompiledGraph
+from pydantic import Field
+from pydantic_settings import (
+    BaseSettings,
+    PydanticBaseSettingsSource,
+    SettingsConfigDict,
+    YamlConfigSettingsSource,
+)
+
+from blaxel.aimon.logger import init as init_logger
+from blaxel.models import Agent, Function, Model
+
+global SETTINGS
+SETTINGS = None
+
+class SettingsAgent(BaseSettings):
+    """
+    Configuration settings for agents within Blaxel.
+
+    Attributes:
+        agent (Union[None, CompiledGraph]): The compiled agent graph.
+        chain (Union[None, list[Agent]]): A list of agent chains.
+        model (Union[None, Model]): The model configuration.
+        functions (Union[None, list[Function]]): A list of functions available to agents.
+        functions_directory (str): The directory path where agent functions are located.
+        chat_model (Union[None, BaseChatModel]): The chat model used by agents.
+        module (str): The module path to the main application.
+    """
+    agent: Union[None, CompiledGraph] = None
+    chain: Union[None, list[Agent]] = None
+    model: Union[None, Model] = None
+    functions: Union[None, list[Function]] = None
+    functions_directory: str = Field(default="src/functions")
+    chat_model: Union[None, BaseChatModel] = None
+    module: str = Field(default="main.main")
+
+
+class SettingsAuthenticationClient(BaseSettings):
+    """
+    Configuration settings for authentication clients.
+
+    Attributes:
+        credentials (Union[None, str]): Client credentials for authentication.
+    """
+    credentials: Union[None, str] = None
+
+
+class SettingsAuthentication(BaseSettings):
+    apiKey: Union[None, str] = None
+    jwt: Union[None, str] = None
+    client: SettingsAuthenticationClient = SettingsAuthenticationClient()
+
+
+class SettingsServer(BaseSettings):
+    module: str = Field(default="main.main")
+    port: int = Field(default=80)
+    host: str = Field(default="0.0.0.0")
+    directory: str = Field(default="src")
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(
+        yaml_file="blaxel.yaml",
+        env_prefix="bl_",
+        env_nested_delimiter="_",
+        extra="ignore",
+    )
+
+    workspace: str
+    remote: bool = Field(default=False)
+    type: str = Field(default="agent")
+    name: str = Field(default="blaxel-agent")
+    base_url: str = Field(default="https://api.blaxel.ai/v0")
+    app_url: str = Field(default="https://app.blaxel.ai")
+    run_url: str = Field(default="https://run.blaxel.ai")
+    run_internal_hostname: str = Field(default="internal.run.blaxel.ai")
+    registry_url: str = Field(default="https://us.registry.blaxel.ai")
+    log_level: str = Field(default="INFO")
+    enable_opentelemetry: bool = Field(default=False)
+    cloud: bool = Field(default=False)
+    agent: SettingsAgent = SettingsAgent()
+    server: SettingsServer = SettingsServer()
+    authentication: SettingsAuthentication = SettingsAuthentication()
+
+    def __init__(self, **data):
+        super().__init__(**data)
+        if os.getenv('BL_ENV') == 'dev':
+            self.base_url = os.getenv('BL_BASE_URL') or "https://api.blaxel.dev/v0"
+            self.run_url = os.getenv('BL_RUN_URL') or "https://run.blaxel.dev"
+            self.registry_url = os.getenv('BL_REGISTRY_URL') or "https://eu.registry.blaxel.dev"
+            self.app_url = os.getenv('BL_APP_URL') or "https://app.blaxel.dev"
+
+    @classmethod
+    def settings_customise_sources(
+        cls,
+        settings_cls: Type[BaseSettings],
+        init_settings: PydanticBaseSettingsSource,
+        env_settings: PydanticBaseSettingsSource,
+        dotenv_settings: PydanticBaseSettingsSource,
+        file_secret_settings: PydanticBaseSettingsSource,
+    ) -> Tuple[PydanticBaseSettingsSource, ...]:
+        return (
+            env_settings,
+            dotenv_settings,
+            file_secret_settings,
+            YamlConfigSettingsSource(settings_cls),
+            init_settings,
+        )
+
+def get_settings() -> Settings:
+    """
+    Retrieves the current settings instance.
+
+    Returns:
+        Settings: The current settings configuration.
+    """
+    return SETTINGS
+
+def init() -> Settings:
+    """
+    Initializes the settings by parsing the `blaxel.yaml` file and setting up logging.
+
+    This function reads workspace configuration from the current context,
+    initializes the global SETTINGS variable, and configures the logger based on the log level.
+
+    Returns:
+        Settings: The initialized settings configuration.
+    """
+    from blaxel.authentication.credentials import current_context
+
+    global SETTINGS
+
+    context = current_context()
+    kwargs = {}
+    if context.workspace:
+        kwargs["workspace"] = context.workspace
+
+    SETTINGS = Settings(**kwargs)
+    init_logger(SETTINGS.log_level)
+
+    return SETTINGS

blaxel/common/slugify.py

@@ -0,0 +1,18 @@
+"""
+This module provides utility functions for string manipulation, including slugification.
+The `slugify` function transforms a given string into a URL-friendly slug by replacing spaces and underscores with hyphens and converting the string to lowercase.
+"""
+
+def slugify(name: str) -> str:
+    """
+    Converts a given string into a URL-friendly slug.
+
+    This function transforms the input string by converting it to lowercase and replacing spaces and underscores with hyphens.
+
+    Parameters:
+        name (str): The string to slugify.
+
+    Returns:
+        str: The slugified version of the input string.
+    """
+    return name.lower().replace(" ", "-").replace("_", "-")

blaxel/common/utils.py

@@ -0,0 +1,34 @@
+"""
+This module provides utility functions for file operations within Blaxel.
+It includes functions to copy folders and synchronize directory contents efficiently.
+"""
+
+import filecmp
+import os
+import shutil
+
+
+def copy_folder(source_folder: str, destination_folder: str):
+    """
+    Copies the contents of the source folder to the destination folder.
+
+    This function recursively copies all files and subdirectories from the `source_folder` to the `destination_folder`.
+    It ensures that existing files are only overwritten if they differ from the source.
+
+    Parameters:
+        source_folder (str): The path to the source directory.
+        destination_folder (str): The path to the destination directory.
+
+    Raises:
+        FileNotFoundError: If the source folder does not exist.
+        PermissionError: If the program lacks permissions to read from the source or write to the destination.
+    """
+    for file in os.listdir(source_folder):
+        if os.path.isdir(f"{source_folder}/{file}"):
+            if not os.path.exists(f"{destination_folder}/{file}"):
+                os.makedirs(f"{destination_folder}/{file}")
+            copy_folder(f"{source_folder}/{file}", f"{destination_folder}/{file}")
+        elif not os.path.exists(f"{destination_folder}/{file}") or not filecmp.cmp(
+            f"{source_folder}/{file}", f"{destination_folder}/{file}"
+        ):
+            shutil.copy(f"{source_folder}/{file}", f"{destination_folder}/{file}")

blaxel/deploy/__init__.py

@@ -0,0 +1,8 @@
+"""
+This module provides functions and classes to handle deployment processes within Blaxel.
+It includes utilities to generate deployment configurations and manage deployment-related operations.
+"""
+
+from .deploy import generate_blaxel_deployment
+
+__all__ = ["generate_blaxel_deployment"]

blaxel/deploy/deploy.py

@@ -0,0 +1,316 @@
+"""
+This module provides functionalities to generate and manage Blaxel deployment configurations.
+It includes functions to set default deployment values, create deployment configurations from resources,
+format deployments, and clean up auto-generated deployments.
+"""
+
+import ast
+import json
+import os
+import shutil
+import sys
+from logging import getLogger
+from pathlib import Path
+from typing import Literal
+
+import yaml
+
+from blaxel.aimon import slugify
+from blaxel.aimon.settings import Settings, get_settings, init
+from blaxel.api.agents import get_agent
+from blaxel.authentication import new_client
+from blaxel.client import AuthenticatedClient
+from blaxel.models import (
+    Agent,
+    AgentSpec,
+    Flavor,
+    Function,
+    FunctionSpec,
+    Metadata,
+    MetadataLabels,
+)
+
+from .format import arg_to_dict
+from .parser import Resource, get_description, get_parameters, get_resources
+
+sys.path.insert(0, os.getcwd())
+sys.path.insert(0, os.path.join(os.getcwd(), "src"))
+
+def set_default_values(resource: Resource, deployment: Agent | Function):
+    """
+    Sets default values for a deployment based on the resource and deployment type.
+
+    Parameters:
+        resource (Resource): The resource information.
+        deployment (Agent | Function): The deployment instance to set defaults for.
+
+    Returns:
+        Agent | Function: The updated deployment with default values set.
+    """
+    settings = get_settings()
+    deployment.metadata.workspace = settings.workspace
+    if not deployment.metadata.name:
+        deployment.metadata.name = slugify(resource.name)
+    if not deployment.metadata.display_name:
+        deployment.metadata.display_name = deployment.metadata.name
+    if not deployment.spec.description:
+        deployment.spec.description = get_description(None, resource)
+    if isinstance(deployment, Agent):
+        deployment.spec.functions = []
+        for arg in resource.decorator.keywords:
+            if arg.arg == "remote_functions":
+                if isinstance(arg.value, ast.List):
+                    for value in arg.value.elts:
+                        if isinstance(value, ast.Constant):
+                            deployment.spec.functions.append(slugify(value.value))
+    return deployment
+
+def get_blaxel_deployment_from_resource(
+    settings: Settings,
+    resource: Resource,
+) -> Agent | Function:
+    """
+    Creates a deployment configuration from a given resource.
+
+    Args:
+        resource (Resource): The resource to create a deployment for.
+
+    Returns:
+        Agent | Function: The deployment configuration.
+    """
+    for arg in resource.decorator.keywords:
+        if arg.arg == "agent":
+            if isinstance(arg.value, ast.Dict):
+                value = arg_to_dict(arg.value)
+                metadata = Metadata(**value.get("metadata", {}))
+                spec = AgentSpec(**value.get("spec", {}))
+                agent = Agent(metadata=metadata, spec=spec)
+                if not agent.spec.prompt:
+                    agent.spec.prompt = get_description(None, resource)
+                return set_default_values(resource, agent)
+        if arg.arg == "function":
+            if isinstance(arg.value, ast.Dict):
+                value = arg_to_dict(arg.value)
+                metadata = Metadata(**value.get("metadata", {}))
+                spec = FunctionSpec(**value.get("spec", {}))
+                func = Function(metadata=metadata, spec=spec)
+                if not func.spec.parameters:
+                    func.spec.parameters = get_parameters(resource)
+                return set_default_values(resource, func)
+    if resource.type == "agent":
+        agent = Agent(metadata=Metadata(), spec=AgentSpec())
+        return set_default_values(resource, agent)
+    if resource.type == "function":
+        func = Function(metadata=Metadata(), spec=FunctionSpec())
+        func.spec.parameters = get_parameters(resource)
+        return set_default_values(resource, func)
+    return None
+
+def get_flavors(flavors: list[Flavor]) -> str:
+    """
+    Converts a list of Flavor objects to a JSON string.
+
+    Args:
+        flavors (list[Flavor]): List of Flavor objects.
+
+    Returns:
+        str: JSON string representation of flavors.
+    """
+    if not flavors:
+        return "[]"
+    return json.dumps([flavor.to_dict() for flavor in flavors])
+
+def get_agent_yaml(
+    agent: Agent, functions: list[tuple[Resource, Function]], settings: Settings, client: AuthenticatedClient
+) -> str:
+    """
+    Generates YAML configuration for an agent deployment.
+
+    Args:
+        agent (Agent): Agent deployment configuration
+        functions (list[tuple[Resource, FunctionDeployment]]): List of associated functions
+        settings (Settings): Application settings
+
+    Returns:
+        str: YAML configuration string
+    """
+    try:
+        agent_response = get_agent.sync(agent.metadata.name, client=client)
+        agent.spec.repository = agent_response.spec.repository
+    except Exception:
+        pass
+    agent.spec.functions = agent.spec.functions or []
+    agent.spec.functions = agent.spec.functions + [slugify(function.metadata.name) for (_, function) in functions]
+    agent.metadata.labels = agent.metadata.labels and MetadataLabels.from_dict(agent.metadata.labels) or MetadataLabels()
+    agent.metadata.labels["x-blaxel-auto-generated"] = "true"
+    agent_yaml = yaml.dump(agent.to_dict())
+    template = f"""
+apiVersion: blaxel.ai/v1alpha1
+kind: Agent
+{agent_yaml}
+"""
+    return template
+
+
+def get_function_yaml(function: Function, settings: Settings, client: AuthenticatedClient) -> str:
+    """
+    Generates YAML configuration for a function deployment.
+
+    Args:
+        function (FunctionDeployment): Function deployment configuration
+        settings (Settings): Application settings
+
+    Returns:
+        str: YAML configuration string
+    """
+    function.metadata.labels = function.metadata.labels and MetadataLabels.from_dict(function.metadata.labels) or MetadataLabels()
+    function.metadata.labels["x-blaxel-auto-generated"] = "true"
+    function_yaml = yaml.dump(function.to_dict())
+    return f"""
+apiVersion: blaxel.ai/v1alpha1
+kind: Function
+{function_yaml}
+"""
+
+
+def dockerfile(
+    type: Literal["agent", "function"],
+    resource: Resource,
+    deployment: Agent | Function,
+) -> str:
+    """
+    Generates Dockerfile content for agent or function deployment.
+
+    Args:
+        type (Literal["agent", "function"]): Type of deployment
+        resource (Resource): Resource to be deployed
+        deployment (Agent | Function): Resource configuration
+
+    Returns:
+        str: Dockerfile content
+    """
+    settings = get_settings()
+    if type == "agent":
+        module = f"{resource.module.__file__.split('/')[-1].replace('.py', '')}.{resource.module.__name__}"
+    else:
+        module = f"functions.{resource.module.__file__.split('/')[-1].replace('.py', '')}.{resource.module.__name__}"
+    cmd = ["bl", "serve", "--port", "80", "--module", module]
+    if type == "agent":
+        cmd.append("--remote")
+    cmd_str = ",".join([f'"{c}"' for c in cmd])
+    return f"""
+FROM python:3.12-slim
+
+ARG UV_VERSION="latest"
+RUN apt update && apt install -y curl build-essential
+
+# Install uv.
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/
+RUN curl -fsSL https://raw.githubusercontent.com/beamlit/toolkit/main/install.sh | BINDIR=/bin sh
+WORKDIR /blaxel
+
+# Install the application dependencies.
+COPY pyproject.toml /blaxel/pyproject.toml
+COPY uv.lock /blaxel/uv.lock
+
+COPY README.m[d] /blaxel/README.md
+COPY LICENS[E] /blaxel/LICENSE
+COPY {settings.server.directory} /blaxel/src
+
+RUN uv sync --no-cache --no-dev
+
+ENV PATH="/blaxel/.venv/bin:$PATH"
+
+ENTRYPOINT [{cmd_str}]
+"""
+
+def clean_auto_generated(
+    directory: str,
+    type: Literal["agent", "function"],
+    deployments: list[tuple[Resource, Agent | Function]]
+):
+    """
+    Cleans up auto-generated deployments of a specific type.
+
+    Args:
+        directory (str): Base directory containing deployments.
+        type (Literal["agent", "function"]): Type of deployment to clean ("agent" or "function").
+        deployments (list[tuple[Resource, Agent | Function]]): List of deployment resources and configurations.
+    """
+
+    deploy_dir = Path(directory) / f"{type}s"
+    deploy_names = [d.metadata.name for (_, d) in deployments]
+
+    if deploy_dir.exists():
+        for item_dir in deploy_dir.iterdir():
+            if item_dir.is_dir() and item_dir.name not in deploy_names:
+                yaml_file = item_dir / f"{type}.yaml"
+                if yaml_file.exists():
+                    with open(yaml_file) as f:
+                        try:
+                            content = yaml.safe_load(f)
+                            if content.get("metadata", {}).get("labels", {}).get("x-blaxel-auto-generated") == "true":
+                                shutil.rmtree(item_dir)
+                        except yaml.YAMLError:
+                            continue
+
+def generate_blaxel_deployment(directory: str, name: str):
+    """
+    Generates all necessary deployment files for Blaxel agents and functions.
+
+    Args:
+        directory (str): Target directory for generated files.
+        name (str): Name identifier for the deployment.
+
+    Creates:
+        - Agent and function YAML configurations.
+        - Dockerfiles for each deployment.
+        - Directory structure for agents and functions.
+    """
+    settings = init()
+    client = new_client()
+    logger = getLogger(__name__)
+    logger.info(f"Importing server module: {settings.server.module}")
+    functions: list[tuple[Resource, Function]] = []
+    agents: list[tuple[Resource, Agent]] = []
+    for resource in get_resources("agent", settings.server.directory):
+        agent = get_blaxel_deployment_from_resource(settings, resource)
+        if name and agent.metadata.name != name:
+            agent.metadata.name = slugify(name)
+        if agent:
+            agents.append((resource, agent))
+    for resource in get_resources("function", settings.server.directory):
+        function = get_blaxel_deployment_from_resource(settings, resource)
+        if function:
+            functions.append((resource, function))
+
+    agents_dir = os.path.join(directory, "agents")
+    functions_dir = os.path.join(directory, "functions")
+    # Create directory if it doesn't exist
+    os.makedirs(agents_dir, exist_ok=True)
+    os.makedirs(functions_dir, exist_ok=True)
+    for resource, agent in agents:
+        # write deployment file
+        agent_dir = os.path.join(agents_dir, agent.metadata.name)
+        os.makedirs(agent_dir, exist_ok=True)
+        with open(os.path.join(agent_dir, "agent.yaml"), "w") as f:
+            content = get_agent_yaml(agent, functions, settings, client)
+            f.write(content)
+        # write dockerfile for build
+        with open(os.path.join(agent_dir, "Dockerfile"), "w") as f:
+            content = dockerfile("agent", resource, agent)
+            f.write(content)
+    for resource, function in functions:
+        # write deployment file
+        function_dir = os.path.join(functions_dir, function.metadata.name)
+        os.makedirs(function_dir, exist_ok=True)
+        with open(os.path.join(function_dir, "function.yaml"), "w") as f:
+            content = get_function_yaml(function, settings, client)
+            f.write(content)
+        # write dockerfile for build
+        with open(os.path.join(function_dir, "Dockerfile"), "w") as f:
+            content = dockerfile("function", resource, function)
+            f.write(content)
+
+    clean_auto_generated(directory, "agent", agents)
+    clean_auto_generated(directory, "function", functions)

blaxel/deploy/format.py

@@ -0,0 +1,46 @@
+"""
+This module provides utility functions to format deployment configurations into YAML-compatible strings.
+It includes functions to convert arguments, parameters, dictionaries, and agent chains into properly formatted JSON or YAML strings.
+"""
+
+import ast
+
+
+def arg_to_list(arg: ast.List):
+    value = []
+    for v in arg.elts:
+        value.append(format_value(v))
+    return value
+
+def format_value(v):
+    """
+    Formats an AST node value into its Python equivalent.
+
+    Args:
+        v (ast.AST): The AST node to format.
+
+    Returns:
+        Any: The formatted Python value.
+    """
+    if isinstance(v, ast.Constant):
+        return v.value
+    elif isinstance(v, ast.Dict):
+        return arg_to_dict(v)
+    elif isinstance(v, ast.List):
+        return arg_to_list(v)
+
+def arg_to_dict(arg: ast.keyword):
+    """
+    Converts an AST keyword argument to a dictionary.
+
+    Args:
+        arg (ast.keyword): The AST keyword argument.
+
+    Returns:
+        dict: The resulting dictionary.
+    """
+    value = {}
+    for k, v in zip(arg.keys, arg.values):
+        if isinstance(k, ast.Constant):
+            value[k.value] = format_value(v)
+    return value