beamlit 0.0.22rc11__py3-none-any.whl → 0.0.23__py3-none-any.whl

beamlit/agents/chat.py

@@ -37,12 +37,13 @@ def get_chat_model(agent_model: AgentDeployment):
     headers = get_authentication_headers(settings)
     headers["X-Beamlit-Environment"] = agent_model.environment
 
-    jwt = headers.pop("X-Beamlit-Authorization").replace("Bearer ", "")
+    jwt = headers.get("X-Beamlit-Authorization", "").replace("Bearer ", "")
     params = {"environment": agent_model.environment}
     chat_classes = {
         "openai": {
             "func": get_openai_chat_model,
             "kwargs": {
+                "http_async_client": client.get_async_httpx_client(),
                 "http_client": client.get_httpx_client(),
             },
         },

beamlit/agents/decorator.py

@@ -1,17 +1,18 @@
 # Import necessary modules
 import ast
+import asyncio
 import importlib
 import os
 from logging import getLogger
 
-from langgraph.checkpoint.memory import MemorySaver
-from langgraph.prebuilt import create_react_agent
-
 from beamlit.api.models import get_model_deployment
 from beamlit.authentication import new_client
 from beamlit.common.settings import get_settings, init
 from beamlit.errors import UnexpectedStatus
 from beamlit.models import AgentDeployment
+from langchain_core.tools import Tool
+from langgraph.checkpoint.memory import MemorySaver
+from langgraph.prebuilt import create_react_agent
 
 from .chat import get_chat_model
 
@@ -35,7 +36,7 @@ def get_functions(dir="src/functions", from_decorator="function"):
                         # Look for function definitions with decorators
                         for node in ast.walk(tree):
                             if (
-                                not isinstance(node, ast.FunctionDef)
+                                (not isinstance(node, ast.FunctionDef) and not isinstance(node, ast.AsyncFunctionDef))
                                 or len(node.decorator_list) == 0
                             ):
                                 continue
@@ -73,7 +74,10 @@ def get_functions(dir="src/functions", from_decorator="function"):
                                 # Get the decorated function
                                 if not is_kit and hasattr(module, func_name):
                                     func = getattr(module, func_name)
-                                    functions.append(func)
+                                    if asyncio.iscoroutinefunction(func):
+                                        functions.append(Tool(name=func.__name__, description=func.__doc__, func=func, coroutine=func))
+                                    else:
+                                        functions.append(Tool(name=func.__name__, description=func.__doc__, func=func))
                     except Exception as e:
                         logger.warning(f"Error processing {file_path}: {e!s}")
     return functions

beamlit/authentication/authentication.py

@@ -51,7 +51,6 @@ def new_client():
     else:
         settings = get_settings()
         credentials = load_credentials_from_settings(settings)
-
         client_config = RunClientWithCredentials(
             credentials=credentials,
             workspace=settings.workspace,

beamlit/authentication/credentials.py

@@ -130,7 +130,7 @@ def load_credentials(workspace_name: str) -> Credentials:
 def load_credentials_from_settings(settings: Settings) -> Credentials:
     return Credentials(
         api_key=settings.authentication.api_key,
-        client_credentials=settings.authentication.client_credentials,
+        client_credentials=settings.authentication.client.credentials,
     )
 
 

beamlit/client.py

@@ -248,7 +248,6 @@ class AuthenticatedClient:
     def get_async_httpx_client(self) -> httpx.AsyncClient:
         """Get the underlying httpx.AsyncClient, constructing a new one if not previously set"""
         if self._async_client is None:
-            self._headers[self.auth_header_name] = f"{self.prefix} {self.token}" if self.prefix else self.token
             self._async_client = httpx.AsyncClient(
                 base_url=self._base_url,
                 cookies=self._cookies,

beamlit/common/settings.py

@@ -2,16 +2,6 @@ import os
 from logging import getLogger
 from typing import List, 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 beamlit.api.functions import get_function_deployment
 from beamlit.api.models import get_model_deployment
 from beamlit.client import AuthenticatedClient
@@ -20,6 +10,11 @@ from beamlit.models.agent_deployment import AgentDeployment
 from beamlit.models.function_deployment import FunctionDeployment
 from beamlit.models.model_deployment import ModelDeployment
 from beamlit.types import UNSET, Unset
+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)
 
 global SETTINGS
 SETTINGS = None
@@ -39,10 +34,14 @@ class SettingsAgent(BaseSettings):
     module: str = Field(default="main.main")
 
 
+class SettingsAuthenticationClient(BaseSettings):
+    credentials: Union[None, str] = None
+
+
 class SettingsAuthentication(BaseSettings):
     api_key: Union[None, str] = None
     jwt: Union[None, str] = None
-    client_credentials: Union[None, str] = None
+    client: SettingsAuthenticationClient = SettingsAuthenticationClient()
 
 
 class SettingsServer(BaseSettings):
@@ -56,14 +55,17 @@ class Settings(BaseSettings):
         yaml_file="beamlit.yaml",
         env_prefix="bl_",
         env_nested_delimiter="_",
+        extra="ignore",
     )
 
     workspace: str
     environment: str = Field(default="production")
+    remote: bool = Field(default=False)
     type: str = Field(default="agent")
     name: str = Field(default="beamlit-agent")
     base_url: str = Field(default="https://api.beamlit.dev/v0")
     run_url: str = Field(default="https://run.beamlit.dev")
+    registry_url: str = Field(default="https://serverless-registry-production.beamlit.workers.dev")
     log_level: str = Field(default="INFO")
     agent: SettingsAgent = SettingsAgent()
     server: SettingsServer = SettingsServer()

beamlit/deploy/__init__.py

@@ -0,0 +1,3 @@
+from .deploy import generate_beamlit_deployment
+
+__all__ = ["generate_beamlit_deployment"]

beamlit/deploy/deploy.py

@@ -0,0 +1,503 @@
+import ast
+import importlib
+import json
+import os
+import sys
+from dataclasses import dataclass
+from logging import getLogger
+from typing import Callable, Literal
+
+from beamlit.common.settings import Settings, get_settings, init
+from beamlit.models import (AgentChain, AgentDeployment, Flavor,
+                            FunctionDeployment, Runtime,
+                            StoreFunctionParameter)
+
+sys.path.insert(0, os.getcwd())
+sys.path.insert(0, os.path.join(os.getcwd(), "src"))
+
+
+@dataclass
+class Resource:
+    type: Literal["agent", "function"]
+    module: Callable
+    name: str
+    decorator: ast.Call
+    func: Callable
+
+def get_resources(from_decorator, dir="src") -> list[Resource]:
+    """
+    Scans through Python files in a directory to find functions decorated with a specific decorator.
+
+    Args:
+        from_decorator (str): The name of the decorator to search for
+        dir (str): The directory to scan, defaults to "src"
+
+    Returns:
+        list[Resource]: List of Resource objects containing information about decorated functions
+    """
+    resources = []
+    logger = getLogger(__name__)
+
+    # Walk through all Python files in resources directory and subdirectories
+    for root, _, files in os.walk(dir):
+        for file in files:
+            if file.endswith(".py"):
+                file_path = os.path.join(root, file)
+                # Read and compile the file content
+                with open(file_path) as f:
+                    try:
+                        file_content = f.read()
+                        # Parse the file content to find decorated resources
+                        tree = ast.parse(file_content)
+
+                        # Look for function definitions with decorators
+                        for node in ast.walk(tree):
+                            if (
+                                not isinstance(node, ast.FunctionDef) and not isinstance(node, ast.AsyncFunctionDef)
+                            ) or len(node.decorator_list) == 0:
+                                continue
+                            decorator = node.decorator_list[0]
+
+                            decorator_name = ""
+                            if isinstance(decorator, ast.Call):
+                                decorator_name = decorator.func.id
+                            if isinstance(decorator, ast.Name):
+                                decorator_name = decorator.id
+                            if decorator_name == from_decorator:
+                                # Get the function name and decorator name
+                                func_name = node.name
+
+                                # Import the module to get the actual function
+                                spec = importlib.util.spec_from_file_location(func_name, file_path)
+                                module = importlib.util.module_from_spec(spec)
+                                spec.loader.exec_module(module)
+                                # Check if kit=True in the decorator arguments
+
+                                # Get the decorated function
+                                if hasattr(module, func_name) and isinstance(decorator, ast.Call):
+
+                                    resources.append(
+                                        Resource(
+                                            type=decorator_name,
+                                            module=module,
+                                            name=func_name,
+                                            func=getattr(module, func_name),
+                                            decorator=decorator,
+                                        )
+                                    )
+                    except Exception as e:
+                        logger.warning(f"Error processing {file_path}: {e!s}")
+    return resources
+
+
+def get_parameters(resource: Resource) -> list[StoreFunctionParameter]:
+    """
+    Extracts parameter information from a function's signature and docstring.
+
+    Args:
+        resource (Resource): The resource object containing the function to analyze
+
+    Returns:
+        list[StoreFunctionParameter]: List of parameter objects with name, type, required status, and description
+    """
+    parameters = []
+    # Get function signature
+    import inspect
+    sig = inspect.signature(resource.func)
+    # Get docstring for parameter descriptions
+    docstring = inspect.getdoc(resource.func)
+    param_descriptions = {}
+    if docstring:
+        # Parse docstring for parameter descriptions
+        lines = docstring.split('\n')
+        for line in lines:
+            line = line.strip().lower()
+            if line.startswith(':param '):
+                # Extract parameter name and description
+                param_line = line[7:].split(':', 1)
+                if len(param_line) == 2:
+                    param_name = param_line[0].strip()
+                    param_desc = param_line[1].strip()
+                    param_descriptions[param_name] = param_desc
+    for name, param in sig.parameters.items():
+        # Skip *args and **kwargs parameters
+        if param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
+
+            continue
+
+        param_type = "string"  # Default type
+        type_mapping = {
+            'str': 'string',
+            'int': 'integer',
+            'float': 'number',
+            'bool': 'boolean',
+            'list': 'array',
+            'dict': 'object',
+            'none': 'null'
+        }
+        if param.annotation != inspect.Parameter.empty:
+            # Map Python types to OpenAPI types
+            if hasattr(param.annotation, "__name__"):
+                param_type = param.annotation.__name__.lower()
+            else:
+                # Handle special types like Union, Optional etc
+                param_type = str(param.annotation).lower()
+        parameter = StoreFunctionParameter(
+            name=name,
+            type_=type_mapping.get(param_type, "string"),
+            required=param.default == inspect.Parameter.empty,
+            description=param_descriptions.get(name, f"Parameter {name}")
+        )
+        parameters.append(parameter)
+
+    return parameters
+
+
+def get_description(description: str | None, resource: Resource) -> str:
+    """
+    Gets the description of a function from either a provided description or the function's docstring.
+
+    Args:
+        description (str | None): Optional explicit description
+        resource (Resource): The resource object containing the function
+
+    Returns:
+        str: The function description
+    """
+    if description:
+        return description
+    doc = resource.func.__doc__
+    if doc:
+        # Split docstring into sections and get only the description part
+        doc_lines = doc.split('\n')
+        description_lines = []
+        for line in doc_lines:
+            line = line.strip()
+            # Stop when we hit param/return sections
+            if line.startswith(':param') or line.startswith(':return'):
+                break
+            if line:
+                description_lines.append(line)
+        return ' '.join(description_lines).strip()
+    return ""
+
+def get_kwargs(arg: ast.Call) -> dict:
+    """
+    Extracts keyword arguments from an AST Call node.
+
+    Args:
+        arg (ast.Call): The AST Call node to process
+
+    Returns:
+        dict: Dictionary of keyword arguments and their values
+    """
+    kwargs = {}
+    for keyword in arg.keywords:
+        if isinstance(keyword.value, ast.Constant):
+            kwargs[keyword.arg] = keyword.value.value
+        elif isinstance(keyword.value, (ast.List, ast.Tuple)):
+            kwargs[keyword.arg] = [
+                AgentChain(**get_kwargs(elem)) if isinstance(elem, ast.Call) and isinstance(elem.func, ast.Name) and elem.func.id == "AgentChain"
+                else elem.value if isinstance(elem, ast.Constant) else elem
+                for elem in keyword.value.elts
+            ]
+        elif isinstance(keyword.value, ast.Dict):
+            kwargs[keyword.arg] = {}
+            for k, v in zip(keyword.value.keys, keyword.value.values):
+                if isinstance(k, ast.Constant) and isinstance(v, ast.Constant):
+                    kwargs[keyword.arg][k.value] = v.value
+                if isinstance(k, ast.Constant) and isinstance(v, ast.Call):
+                    kwargs[keyword.arg][k.value] = get_kwargs(v)
+    return kwargs
+
+def get_runtime(type: str, name: str) -> Runtime:
+    settings = get_settings()
+    registry_url = settings.registry_url.replace("https://", "").replace("http://", "")
+    image = f"{registry_url}/{settings.workspace}/{type}s/{name}"
+    return Runtime(image=image)
+
+def get_beamlit_deployment_from_resource(resource: Resource) -> AgentDeployment | FunctionDeployment:
+    """
+    Creates a deployment configuration from a resource.
+
+    Args:
+        resource (Resource): The resource to create a deployment for
+
+    Returns:
+        AgentDeployment | FunctionDeployment: The deployment configuration
+    """
+    for arg in resource.decorator.args:
+        if isinstance(arg, ast.Call):
+            if isinstance(arg.func, ast.Name) and arg.func.id == "AgentDeployment":
+                kwargs = get_kwargs(arg)
+                description = kwargs.pop("description", None)
+                return AgentDeployment(
+                    **kwargs,
+                    description=get_description(description, resource),
+                    runtime=get_runtime("agent", kwargs.get("agent", resource.name))
+                )
+            if isinstance(arg.func, ast.Name) and arg.func.id == "FunctionDeployment":
+                kwargs = get_kwargs(arg)
+                description = kwargs.pop("description", None)
+                return FunctionDeployment(
+                    **kwargs,
+                    parameters=get_parameters(resource),
+                    description=get_description(description, resource),
+                    runtime=get_runtime("function", kwargs.get("function", resource.name))
+                )
+    for arg in resource.decorator.keywords:
+        if isinstance(arg.value, ast.Call):
+            if isinstance(arg.value.func, ast.Name) and arg.value.func.id == "AgentDeployment":
+                kwargs = get_kwargs(arg.value)
+                description = kwargs.pop("description", None)
+                return AgentDeployment(
+                    **kwargs,
+                    description=get_description(description, resource),
+                    runtime=get_runtime("agent", kwargs.get("agent", resource.name))
+                )
+            if isinstance(arg.value.func, ast.Name) and arg.value.func.id == "FunctionDeployment":
+                kwargs = get_kwargs(arg.value)
+                description = kwargs.pop("description", None)
+                return FunctionDeployment(
+                    **kwargs,
+                    parameters=get_parameters(resource),
+                    description=get_description(description, resource),
+                    runtime=get_runtime("function", kwargs.get("function", resource.name))
+                )
+    if resource.type == "agent":
+        return AgentDeployment(
+            agent=resource.name,
+            description=get_description(None,resource),
+            runtime=get_runtime("agent", resource.name)
+        )
+    if resource.type == "function":
+        return FunctionDeployment(
+            function=resource.name,
+            parameters=get_parameters(resource),
+            description=get_description(None,resource),
+            runtime=get_runtime("function", resource.name)
+        )
+    return None
+
+
+def get_flavors(flavors: list[Flavor]) -> str:
+    """
+    Converts a list of Flavor objects to 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 format_parameters(parameters: list[StoreFunctionParameter]) -> str:
+    """
+    Formats function parameters into YAML-compatible string.
+
+    Args:
+        parameters (list[StoreFunctionParameter]): List of parameter objects
+
+    Returns:
+        str: YAML-formatted string of parameters
+    """
+    if not parameters:
+        return "[]"
+
+    formatted = []
+    for param in parameters:
+        formatted.append(f"""
+      - name: {param.name}
+        type: {param.type_}
+        required: {str(param.required).lower()}
+        description: {param.description}""")
+
+    return "\n".join(formatted)
+
+def format_agent_chain(agent_chain: list[AgentChain]) -> str:
+    """
+    Formats agent chain configuration into YAML-compatible string.
+
+    Args:
+        agent_chain (list[AgentChain]): List of agent chain configurations
+
+    Returns:
+        str: YAML-formatted string of agent chain
+    """
+    if not agent_chain:
+        return "[]"
+    formatted = []
+
+    for agent in agent_chain:
+        formatted.append(f"""
+      - agent: {agent.name}
+        enabled: {agent.enabled}""")
+        if agent.description:
+            formatted.append(f"        description: {agent.description}")
+    return "\n".join(formatted)
+
+def get_agent_yaml(agent: AgentDeployment, functions: list[tuple[Resource, FunctionDeployment]], settings: Settings) -> str:
+    """
+    Generates YAML configuration for an agent deployment.
+
+    Args:
+        agent (AgentDeployment): Agent deployment configuration
+        functions (list[tuple[Resource, FunctionDeployment]]): List of associated functions
+        settings (Settings): Application settings
+
+    Returns:
+        str: YAML configuration string
+    """
+    template = f"""
+apiVersion: beamlit.com/v1alpha1
+kind: Agent
+metadata:
+  name: {agent.agent}
+spec:
+  display_name: {agent.agent}
+  deployments:
+  - environment: {settings.environment}
+    enabled: true
+    policies: [{", ".join(agent.policies or [])}]
+    functions: [{", ".join([f"{function.function}" for (_, function) in functions])}]
+    agent_chain: {format_agent_chain(agent.agent_chain)}
+    model: {agent.model}
+    runtime:
+      image: {agent.runtime.image}
+"""
+    if agent.description:
+        template += f"""    description: |
+      {agent.description}"""
+    return template
+
+def get_function_yaml(function: FunctionDeployment, settings: Settings) -> str:
+    """
+    Generates YAML configuration for a function deployment.
+
+    Args:
+        function (FunctionDeployment): Function deployment configuration
+        settings (Settings): Application settings
+
+    Returns:
+        str: YAML configuration string
+    """
+    return f"""
+apiVersion: beamlit.com/v1alpha1
+kind: Function
+metadata:
+  name: {function.function}
+spec:
+  display_name: {function.function}
+  deployments:
+  - environment: {settings.environment}
+    enabled: true
+    policies: [{", ".join(function.policies or [])}]
+    description: |
+      {function.description}
+    parameters: {format_parameters(function.parameters)}
+    runtime:
+      image: {function.runtime.image}
+"""
+
+def dockerfile(type: Literal["agent", "function"], resource: Resource, deployment: AgentDeployment | FunctionDeployment) -> str:
+    """
+    Generates Dockerfile content for agent or function deployment.
+
+    Args:
+        type (Literal["agent", "function"]): Type of deployment
+        resource (Resource): Resource to be deployed
+        deployment (AgentDeployment | FunctionDeployment): Deployment configuration
+
+    Returns:
+        str: Dockerfile content
+    """
+    if type == "agent":
+        module = f"{resource.module.__file__.split('/')[-1].replace('.py', '')}.{resource.module.__name__}"
+    else:
+        module = f"functions.{resource.module.__name__}.{resource.func.__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
+
+# 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 /beamlit
+
+# Install the application dependencies.
+COPY pyproject.toml /beamlit/pyproject.toml
+COPY uv.lock /beamlit/uv.lock
+RUN uv sync --no-cache
+
+COPY README.md /beamlit/README.md
+COPY LICENSE /beamlit/LICENSE
+COPY src /beamlit/src
+
+ENV PATH="/beamlit/.venv/bin:$PATH"
+
+ENTRYPOINT [{cmd_str}]
+"""
+
+def generate_beamlit_deployment(directory: str):
+    """
+    Generates all necessary deployment files for Beamlit agents and functions.
+
+    Args:
+        directory (str): Target directory for generated files
+
+    Creates:
+        - Agent and function YAML configurations
+        - Dockerfiles for each deployment
+        - Directory structure for agents and functions
+    """
+    settings = init()
+    logger = getLogger(__name__)
+    logger.info(f"Importing server module: {settings.server.module}")
+    functions: list[tuple[Resource, FunctionDeployment]] = []
+    agents: list[tuple[Resource, AgentDeployment]] = []
+    for agent in get_resources("agent"):
+        agent_deployment = get_beamlit_deployment_from_resource(agent)
+        if agent_deployment:
+            agents.append((agent, agent_deployment))
+    for function in get_resources("function"):
+        function_deployment = get_beamlit_deployment_from_resource(function)
+        if function_deployment:
+            functions.append((function, function_deployment))
+
+    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.agent)
+        os.makedirs(agent_dir, exist_ok=True)
+        with open(os.path.join(agent_dir, f"agent.yaml"), "w") as f:
+            content = get_agent_yaml(agent, functions, settings)
+            f.write(content)
+        # write dockerfile for build
+        with open(os.path.join(agent_dir, f"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.function)
+        os.makedirs(function_dir, exist_ok=True)
+        with open(os.path.join(function_dir, f"function.yaml"), "w") as f:
+            content = get_function_yaml(function, settings)
+            f.write(content)
+        # write dockerfile for build
+        with open(os.path.join(function_dir, f"Dockerfile"), "w") as f:
+            content = dockerfile("function", resource, function)
+            f.write(content)

beamlit/functions/decorator.py

@@ -3,12 +3,11 @@
 from collections.abc import Callable
 from logging import getLogger
 
-from langchain_core.tools import create_schema_from_function, tool
-
 from beamlit.authentication import new_client
 from beamlit.common.settings import get_settings
 from beamlit.models import FunctionDeployment, FunctionKit
 from beamlit.run import RunClient
+from langchain_core.tools import create_schema_from_function
 
 logger = getLogger(__name__)
 
@@ -58,7 +57,7 @@ def kit(bl_kit: FunctionKit = None, **kwargs: dict) -> Callable:
     def wrapper(func: Callable) -> Callable:
         if bl_kit and not func.__doc__ and bl_kit.description:
             func.__doc__ = bl_kit.description
-        return tool(func, **kwargs)
+        return func
 
     return wrapper
 
@@ -72,10 +71,7 @@ def function(
     def wrapper(func: Callable) -> Callable:
         if bl_function and not func.__doc__ and bl_function.description:
             func.__doc__ = bl_function.description
-        if (
-            settings.environment == "development"
-            or settings.environment == "production"
-        ):
+        if settings.remote:
             remote_func = get_remote_function(func, bl_function)
             if not kwargs.get("args_schema"):
                 kwargs["args_schema"] = create_schema_from_function(
@@ -83,8 +79,7 @@ def function(
                     func,
                     parse_docstring=func.__doc__,
                 )
-            return tool(remote_func, **kwargs)
-        return tool(func, **kwargs)
+            return remote_func
+        return func
 
     return wrapper
-    return wrapper

beamlit/serve/app.py

@@ -16,7 +16,6 @@ from .middlewares import AccessLogMiddleware, AddProcessTimeHeader
 sys.path.insert(0, os.getcwd())
 sys.path.insert(0, os.path.join(os.getcwd(), "src"))
 
-
 def import_module():
     settings = get_settings()
     main_module = importlib.import_module(".".join(settings.server.module.split(".")[0:-1]))

{beamlit-0.0.22rc11.dist-info → beamlit-0.0.23.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: beamlit
-Version: 0.0.22rc11
+Version: 0.0.23
 Summary: Add your description here
 Author-email: cploujoux <ch.ploujoux@gmail.com>
 Requires-Python: >=3.12

{beamlit-0.0.22rc11.dist-info → beamlit-0.0.23.dist-info}/RECORD

@@ -1,12 +1,12 @@
 beamlit/__init__.py,sha256=545gFC-wLLwUktWcOAjUWe_Glha40tBetRTOYSfHnbI,164
-beamlit/client.py,sha256=vwvjAkUKHRySnA2tOVzXI8xtm9s1k2sEklCRE4j1Vc8,12543
+beamlit/client.py,sha256=OdRbs5VVHF32HUd5RMcnkhe8YxamnAmgGlxO6pm1Xac,12431
 beamlit/errors.py,sha256=gO8GBmKqmSNgAg-E5oT-oOyxztvp7V_6XG7OUTT15q0,546
 beamlit/py.typed,sha256=8ZJUsxZiuOy1oJeVhsTWQhTG_6pTVHVXk5hJL79ebTk,25
 beamlit/run.py,sha256=y61iDBaR0917ihj5q-cJ_r3BFW1Rn5K_kDAISw5O6aU,1339
 beamlit/types.py,sha256=E1hhDh_zXfsSQ0NCt9-uw90_Mr5iIlsdfnfvxv5HarU,1005
 beamlit/agents/__init__.py,sha256=nf1iwQwGtCG6nDqyVhxfWoqR6dv6X3bvSpCeqkTCFaM,101
-beamlit/agents/chat.py,sha256=8KsUvIB-eaUApfKclT76_4HQu3VBa9nifMqmq_AAvcM,2630
-beamlit/agents/decorator.py,sha256=naeOsvfto74TZTcc15Ro98Hl8Bbe6Uhflof_SdyUkwY,6054
+beamlit/agents/chat.py,sha256=aI7pObyywRyg3dBpubzHAUWTbTk1nwtxvpY7iIP1RLY,2704
+beamlit/agents/decorator.py,sha256=XDrWN-Xx4czSy1sIkfQY4t9-UnsM21vMll58CP1TRLw,6468
 beamlit/api/__init__.py,sha256=zTSiG_ujSjAqWPyc435YXaX9XTlpMjiJWBbV-f-YtdA,45
 beamlit/api/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 beamlit/api/agents/create_agent.py,sha256=HFExosu02JZqZz7I6U6WjN81TERz6p2i8CzQCyiRYXo,4112
@@ -130,18 +130,20 @@ beamlit/api/workspaces/update_workspace.py,sha256=qa5DV2UJSUYuB_ibALb4E9ghKpT1Ha
 beamlit/api/workspaces/update_workspace_user_role.py,sha256=Yn9iuJ4tKtauzBiJyU4-wYUMS9g98X2Om8zs7UkzrY8,4917
 beamlit/authentication/__init__.py,sha256=wiXqRbc7E-ulrH_ueA9duOGFvXeo7-RvhSD1XbFogMo,1020
 beamlit/authentication/apikey.py,sha256=jnz1FMRauI5qAInqeeDER8aCONx4O8ZPZGedvi3Ap_o,659
-beamlit/authentication/authentication.py,sha256=om26AteY2cCV9ctqbOCynX6PgS8YO-aCreNOFSnnWKc,3121
+beamlit/authentication/authentication.py,sha256=tZu8GoVueKDuq1RLXMvtHcV95XLikmQ19PCxLWBn2Ek,3120
 beamlit/authentication/clientcredentials.py,sha256=6kbfTjwUkXUArJX8XZLe9ZzbEicQc19tSXBvsTpiXMk,3954
-beamlit/authentication/credentials.py,sha256=DBw598T6it7EgXKnS_qfsBM0mkC33iRDadWA70bg5X0,5349
+beamlit/authentication/credentials.py,sha256=DlfiF_FfOosPVsRoa39JSR3XoICmhBqTlHXc6b4zWtE,5349
 beamlit/authentication/device_mode.py,sha256=oQVBCDsq-pdeXF31WSTAAEdaX6eACV7SYcOSyf3ea_Q,3728
 beamlit/common/__init__.py,sha256=yDoMJDKj-xjTGl7U1YI59KpWxiOV65HSiUulgO8xdTA,277
 beamlit/common/generate.py,sha256=VJ_MiRDulXdQdnlKdM4_Bod6CO6DOGlFiosGXOLuLGs,7227
 beamlit/common/logger.py,sha256=ayabnsoHS8ncXm8EpBS01FkvSe0XRcaNdQjKVuPI5z4,1025
 beamlit/common/secrets.py,sha256=sid81bOe3LflkMKDHwBsBs9nIju8bp5-v9qU9gkyNMc,212
-beamlit/common/settings.py,sha256=7PDfLPzTPN5Yeh2NnmAlSzpBi_u-qza2lUIX-i6N_lg,5252
+beamlit/common/settings.py,sha256=N0VzveNQ3vAE6ZJWMnWrIVi2hXidLtkRZkAXQTGo40A,5546
 beamlit/common/utils.py,sha256=jouz5igBvT37Xn_e94-foCHyQczVim-UzVcoIF6RWJ4,657
+beamlit/deploy/__init__.py,sha256=GS7l7Jtm2yKs7iNLKcfjYO-rAhUzggQ3xiYSf3oxLBY,91
+beamlit/deploy/deploy.py,sha256=bWUXG_5b_XhFcG5t75vel2EbEfZPIdg_YLXtzkfgXUs,18799
 beamlit/functions/__init__.py,sha256=_RPG1Bfg54JGdIPnViAU6n9zD7E1cDNsdXi8oYGskzE,138
-beamlit/functions/decorator.py,sha256=-2newMBztweIgFuh0ABKOdxCfUzWaRxf0ym-YAgggJI,3168
+beamlit/functions/decorator.py,sha256=uYZOVxD-7ZNHORTQfCIn0qdNKPIZupsr7_QdUmWEKu0,2996
 beamlit/functions/github/__init__.py,sha256=gYnUkeegukOfbymdabuuJkScvH-_ZJygX05BoqkPn0o,49
 beamlit/functions/github/github.py,sha256=FajzLCNkpXcwfgnC0l9rOGT2eSPLCz8-qrMzK9N_ZNc,598
 beamlit/functions/github/kit/__init__.py,sha256=jBwPqZv6C23_utukohxqXZwrlicNlI7PYPUj0Den7Cw,136
@@ -292,10 +294,10 @@ beamlit/models/websocket_channel.py,sha256=tyNtsVR0cOwd6BK--ehBCH8bIjxtyPhiAkrxY
 beamlit/models/workspace.py,sha256=s7wS6ibswosB0FdUb3ry3BnlLa325axBdYPLI3ipe0Q,3986
 beamlit/models/workspace_labels.py,sha256=WbnUY6eCTkUNdY7hhhSF-KQCl8fWFfkCf7hzCTiNp4A,1246
 beamlit/models/workspace_user.py,sha256=70CcifQWYbeWG7TDui4pblTzUe5sVK0AS19vNCzKE8g,3423
-beamlit/serve/app.py,sha256=-CvUU7pqFDigndHpA01IR4_mxXaT8c0VsnVjMfIw6K8,2399
+beamlit/serve/app.py,sha256=_0ZesKcczd1sYm8vs3ulbXO1M1boO_5DhFf3jSmjM4g,2398
 beamlit/serve/middlewares/__init__.py,sha256=1dVmnOmhAQWvWktqHkKSIX-YoF6fmMU8xkUQuhg_rJU,148
 beamlit/serve/middlewares/accesslog.py,sha256=wM52-hcwtO-_hdM1pnsEJzerzJf1MzEyN5m85BdDccE,609
 beamlit/serve/middlewares/processtime.py,sha256=lDAaIasZ4bwvN-HKHvZpaD9r-yrkVNZYx4abvbjbrCg,411
-beamlit-0.0.22rc11.dist-info/METADATA,sha256=AOUr4a-4i_HzlZwKbn12EyaSvGR2BJFEFdzs4WXPqRw,2027
-beamlit-0.0.22rc11.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-beamlit-0.0.22rc11.dist-info/RECORD,,
+beamlit-0.0.23.dist-info/METADATA,sha256=3o33Ckt9YG7lMNqHL9niFXXNSeQCLZUWX7BavDh7ZjI,2023
+beamlit-0.0.23.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+beamlit-0.0.23.dist-info/RECORD,,

{beamlit-0.0.22rc11.dist-info → beamlit-0.0.23.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.26.3
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any