beamlit 0.0.34rc61__tar.gz → 0.0.34rc63__tar.gz

{beamlit-0.0.34rc61 → beamlit-0.0.34rc63}/PKG-INFO

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

{beamlit-0.0.34rc61 → beamlit-0.0.34rc63}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "beamlit"
-version = "0.0.34.pre-61"
+version = "0.0.34.pre-63"
 description = "Add your description here"
 readme = "README.md"
 authors = [

{beamlit-0.0.34rc61 → beamlit-0.0.34rc63}/src/beamlit/agents/chat.py

@@ -1,4 +1,7 @@
 from logging import getLogger
+from typing import Tuple, Union
+
+from langchain_core.language_models import BaseChatModel
 
 from beamlit.authentication import get_authentication_headers, new_client
 from beamlit.common.settings import get_settings
@@ -39,11 +42,11 @@ def get_cohere_chat_model(**kwargs):
 
     return ChatCohere(**kwargs)
 
-def get_chat_model(name: str, agent_model: Model):
+def get_chat_model(name: str, agent_model: Union[Model, None] = None) -> Tuple[BaseChatModel, str, str]:
     settings = get_settings()
     client = new_client()
 
-    environment = (agent_model.metadata and agent_model.metadata.environment) or settings.environment
+    environment = (agent_model and agent_model.metadata and agent_model.metadata.environment) or settings.environment
     headers = get_authentication_headers(settings)
     headers["X-Beamlit-Environment"] = environment
 
@@ -84,7 +87,8 @@ def get_chat_model(name: str, agent_model: Model):
     }
 
     provider = (
-        agent_model.spec
+        agent_model
+        and agent_model.spec
         and agent_model.spec.runtime
         and agent_model.spec.runtime.type_
     )
@@ -93,7 +97,8 @@ def get_chat_model(name: str, agent_model: Model):
         provider = "openai"
 
     model = (
-        agent_model.spec
+        agent_model
+        and agent_model.spec
         and agent_model.spec.runtime
         and agent_model.spec.runtime.model
     )

beamlit-0.0.34rc63/src/beamlit/agents/decorator.py

@@ -0,0 +1,108 @@
+# Import necessary modules
+import functools
+from logging import getLogger
+
+from langgraph.checkpoint.memory import MemorySaver
+from langgraph.prebuilt import create_react_agent
+
+from beamlit.api.models import get_model
+from beamlit.authentication import new_client
+from beamlit.common.settings import init
+from beamlit.errors import UnexpectedStatus
+from beamlit.functions import get_functions
+from beamlit.models import Agent, AgentMetadata, AgentSpec
+
+from .chat import get_chat_model
+
+
+def agent(
+    agent: Agent | dict = None,
+    override_model=None,
+    override_agent=None,
+    mcp_hub=None,
+    remote_functions=None,
+):
+    logger = getLogger(__name__)
+    try:
+        if agent is not None and not isinstance(agent, dict):
+            raise Exception(
+                'agent must be a dictionary, example: @agent(agent={"metadata": {"name": "my_agent"}})'
+            )
+
+        client = new_client()
+        chat_model = override_model or None
+        settings = init()
+
+        def wrapper(func):
+            @functools.wraps(func)
+            def wrapped(*args, **kwargs):
+                return func(
+                    settings.agent.agent,
+                    settings.agent.chat_model,
+                    settings.agent.functions,
+                    *args,
+                    **kwargs,
+                )
+
+            return wrapped
+
+        if agent is not None:
+            metadata = AgentMetadata(**agent.get("metadata", {}))
+            spec = AgentSpec(**agent.get("spec", {}))
+            agent = Agent(metadata=metadata, spec=spec)
+            if agent.spec.model and chat_model is None:
+                try:
+                    response = get_model.sync_detailed(
+                        agent.spec.model, environment=settings.environment, client=client
+                    )
+                    settings.agent.model = response.parsed
+                except UnexpectedStatus as e:
+                    if e.status_code == 404 and settings.environment != "production":
+                        try:
+                            response = get_model.sync_detailed(
+                                agent.spec.model, environment="production", client=client
+                            )
+                            settings.agent.model = response.parsed
+                        except UnexpectedStatus as e:
+                            if e.status_code == 404:
+                                raise ValueError(f"Model {agent.spec.model} not found")
+                    else:
+                        raise e
+                except Exception as e:
+                    raise e
+
+                if settings.agent.model:
+                    chat_model, provider, model = get_chat_model(agent.spec.model, settings.agent.model)
+                    settings.agent.chat_model = chat_model
+                    logger.info(f"Chat model configured, using: {provider}:{model}")
+
+        functions = get_functions(
+            client=client,
+            dir=settings.agent.functions_directory,
+            mcp_hub=mcp_hub,
+            remote_functions=remote_functions,
+            chain=agent.spec.agent_chain,
+            remote_functions_empty=not remote_functions,
+        )
+        settings.agent.functions = functions
+        
+        if override_agent is None and len(functions) == 0:
+            raise ValueError(
+                "You must define at least one function, you can define this function in directory "
+                f'"{settings.agent.functions_directory}". Here is a sample function you can use:\n\n'
+                "from beamlit.functions import function\n\n"
+                "@function()\n"
+                "def hello_world(query: str):\n"
+                "    return 'Hello, world!'\n"
+            )
+
+        if override_agent is None and chat_model is not None:
+            memory = MemorySaver()
+            _agent = create_react_agent(chat_model, functions, checkpointer=memory)
+            settings.agent.agent = _agent
+        else:
+            settings.agent.agent = override_agent
+        return wrapper
+    except Exception as e:
+        logger.error(f"Error in agent decorator: {e!s} at line {e.__traceback__.tb_lineno}")
+        raise e

{beamlit-0.0.34rc61 → beamlit-0.0.34rc63}/src/beamlit/api/service_accounts/create_workspace_service_account.py

@@ -6,7 +6,9 @@ import httpx
 from ... import errors
 from ...client import AuthenticatedClient, Client
 from ...models.create_workspace_service_account_body import CreateWorkspaceServiceAccountBody
-from ...models.create_workspace_service_account_response_200 import CreateWorkspaceServiceAccountResponse200
+from ...models.create_workspace_service_account_response_200 import (
+    CreateWorkspaceServiceAccountResponse200,
+)
 from ...types import Response
 
 

{beamlit-0.0.34rc61 → beamlit-0.0.34rc63}/src/beamlit/api/service_accounts/delete_workspace_service_account.py

@@ -5,7 +5,9 @@ import httpx
 
 from ... import errors
 from ...client import AuthenticatedClient, Client
-from ...models.delete_workspace_service_account_response_200 import DeleteWorkspaceServiceAccountResponse200
+from ...models.delete_workspace_service_account_response_200 import (
+    DeleteWorkspaceServiceAccountResponse200,
+)
 from ...types import Response
 
 

{beamlit-0.0.34rc61 → beamlit-0.0.34rc63}/src/beamlit/api/service_accounts/get_workspace_service_accounts.py

@@ -5,7 +5,9 @@ import httpx
 
 from ... import errors
 from ...client import AuthenticatedClient, Client
-from ...models.get_workspace_service_accounts_response_200_item import GetWorkspaceServiceAccountsResponse200Item
+from ...models.get_workspace_service_accounts_response_200_item import (
+    GetWorkspaceServiceAccountsResponse200Item,
+)
 from ...types import Response
 
 

{beamlit-0.0.34rc61 → beamlit-0.0.34rc63}/src/beamlit/api/service_accounts/update_workspace_service_account.py

@@ -6,7 +6,9 @@ import httpx
 from ... import errors
 from ...client import AuthenticatedClient, Client
 from ...models.update_workspace_service_account_body import UpdateWorkspaceServiceAccountBody
-from ...models.update_workspace_service_account_response_200 import UpdateWorkspaceServiceAccountResponse200
+from ...models.update_workspace_service_account_response_200 import (
+    UpdateWorkspaceServiceAccountResponse200,
+)
 from ...types import Response
 
 

{beamlit-0.0.34rc61 → beamlit-0.0.34rc63}/src/beamlit/deploy/deploy.py

@@ -3,11 +3,15 @@ import json
 import os
 import shutil
 import sys
-from pathlib import Path
-import yaml
 from logging import getLogger
+from pathlib import Path
 from typing import Literal
 
+import yaml
+
+from beamlit.api.agents import get_agent
+from beamlit.authentication import new_client
+from beamlit.client import AuthenticatedClient
 from beamlit.common import slugify
 from beamlit.common.settings import Settings, get_settings, init
 from beamlit.models import (
@@ -19,9 +23,7 @@ from beamlit.models import (
     FunctionSpec,
     MetadataLabels,
 )
-from beamlit.api.agents import get_agent
-from beamlit.authentication import new_client
-from beamlit.client import AuthenticatedClient
+
 from .format import arg_to_dict
 from .parser import Resource, get_description, get_parameters, get_resources
 
@@ -110,7 +112,7 @@ def get_agent_yaml(
     try:
         agent_response = get_agent.sync(agent.metadata.name, client=client)
         agent.spec.repository = agent_response.spec.repository
-    except Exception as e:
+    except Exception:
         pass
     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()

beamlit-0.0.34rc63/src/beamlit/functions/__init__.py

@@ -0,0 +1,5 @@
+"""Functions package providing function decorators and utilities."""
+
+from .decorator import function, get_functions, kit
+
+__all__ = ["function", "kit", "get_functions"]

{beamlit-0.0.34rc61/src/beamlit/agents → beamlit-0.0.34rc63/src/beamlit/functions}/decorator.py

@@ -1,30 +1,44 @@
-# Import necessary modules
+"""Decorators for creating function tools with Beamlit and LangChain integration."""
 import ast
 import asyncio
 import functools
-import importlib
+import importlib.util
 import os
+from collections.abc import Callable
 from logging import getLogger
+from typing import Union
 
+from fastapi import Request
 from langchain_core.tools import StructuredTool
-from langgraph.checkpoint.memory import MemorySaver
-from langgraph.prebuilt import create_react_agent
 from langchain_core.tools.base import create_schema_from_function
 
-from beamlit.api.models import get_model
 from beamlit.authentication import new_client
+from beamlit.client import AuthenticatedClient
 from beamlit.common import slugify
-from beamlit.common.settings import get_settings, init
-from beamlit.errors import UnexpectedStatus
+from beamlit.common.settings import get_settings
 from beamlit.functions.mcp.mcp import MCPClient, MCPToolkit
 from beamlit.functions.remote.remote import RemoteToolkit
-from beamlit.models import Agent, AgentMetadata, AgentSpec
-
-from .chain import ChainToolkit
-from .chat import get_chat_model
+from beamlit.models import AgentChain, Function, FunctionKit
+
+logger = getLogger(__name__)
+
+def get_functions(
+    client:Union[AuthenticatedClient, None]=None,
+    dir:Union[str, None]=None,
+    mcp_hub:Union[list[str], None]=None,
+    remote_functions:Union[list[str], None]=None,
+    chain:Union[list[AgentChain], None]=None,
+    remote_functions_empty:bool=True,
+    from_decorator:str="function",
+):
+    from beamlit.agents.chain import ChainToolkit
 
+    settings = get_settings()
+    if client is None:
+        client = new_client()
+    if dir is None:
+        dir = settings.agent.functions_directory
 
-def get_functions(client, dir="src/functions", from_decorator="function", remote_functions_empty=True):
     functions = []
     logger = getLogger(__name__)
     settings = get_settings()
@@ -59,7 +73,6 @@ def get_functions(client, dir="src/functions", from_decorator="function", remote
                                 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
@@ -78,10 +91,10 @@ def get_functions(client, dir="src/functions", from_decorator="function", remote
                                             is_kit = keyword.value.value
                                 if is_kit and not settings.remote:
                                     kit_functions = get_functions(
-                                        client,
+                                        client=client,
                                         dir=os.path.join(root),
-                                        from_decorator="kit",
                                         remote_functions_empty=remote_functions_empty,
+                                        from_decorator="kit",
                                     )
                                     functions.extend(kit_functions)
 
@@ -104,6 +117,7 @@ def get_functions(client, dir="src/functions", from_decorator="function", remote
                                                 )
                                             )
                                         else:
+
                                             functions.append(
                                                 StructuredTool(
                                                     name=func.__name__,
@@ -114,122 +128,65 @@ def get_functions(client, dir="src/functions", from_decorator="function", remote
                                             )
                     except Exception as e:
                         logger.warning(f"Error processing {file_path}: {e!s}")
+
+    if mcp_hub:
+        for server in mcp_hub:
+            try:
+                mcp_client = MCPClient(client, server)
+                toolkit = MCPToolkit(client=mcp_client)
+                toolkit.initialize()
+                functions.extend(toolkit.get_tools())
+            except Exception as e:
+                logger.warn(f"Failed to initialize MCP server {server}: {e!s}")
+
+    if remote_functions:
+        for function in remote_functions:
+            try:
+                toolkit = RemoteToolkit(client, function)
+                toolkit.initialize()
+                functions.extend(toolkit.get_tools())
+            except Exception as e:
+                logger.warn(f"Failed to initialize remote function {function}: {e!s}")
+
+    if chain:
+        toolkit = ChainToolkit(client, chain)
+        toolkit.initialize()
+        functions.extend(toolkit.get_tools())
+
     return functions
 
 
-def agent(
-    agent: Agent | dict = None,
-    override_model=None,
-    override_agent=None,
-    mcp_hub=None,
-    remote_functions=None,
-):
-    logger = getLogger(__name__)
-    try:
-        if agent is not None and not isinstance(agent, dict):
-            raise Exception(
-                'agent must be a dictionary, example: @agent(agent={"metadata": {"name": "my_agent"}})'
-            )
 
-        client = new_client()
-        chat_model = override_model or None
-        settings = init()
-
-        def wrapper(func):
-            @functools.wraps(func)
-            def wrapped(*args, **kwargs):
-                return func(
-                    settings.agent.agent,
-                    settings.agent.chat_model,
-                    settings.agent.functions,
-                    *args,
-                    **kwargs,
-                )
-
-            return wrapped
-
-        # Initialize functions array to store decorated functions
-        functions = get_functions(
-            client,
-            dir=settings.agent.functions_directory,
-            remote_functions_empty=not remote_functions,
-        )
+def kit(bl_kit: FunctionKit = None, **kwargs: dict) -> Callable:
+    """Create function tools with Beamlit and LangChain integration."""
 
-        
-
-        if agent is not None:
-            metadata = AgentMetadata(**agent.get("metadata", {}))
-            spec = AgentSpec(**agent.get("spec", {}))
-            agent = Agent(metadata=metadata, spec=spec)
-            if agent.spec.model and chat_model is None:
-                try:
-                    response = get_model.sync_detailed(
-                        agent.spec.model, environment=settings.environment, client=client
-                    )
-                    settings.agent.model = response.parsed
-                except UnexpectedStatus as e:
-                    if e.status_code == 404 and settings.environment != "production":
-                        try:
-                            response = get_model.sync_detailed(
-                                agent.spec.model, environment="production", client=client
-                            )
-                            settings.agent.model = response.parsed
-                        except UnexpectedStatus as e:
-                            if e.status_code == 404:
-                                raise ValueError(f"Model {agent.spec.model} not found")
-                    else:
-                        raise e
-                except Exception as e:
-                    raise e
-
-                if settings.agent.model:
-                    chat_model, provider, model = get_chat_model(agent.spec.model, settings.agent.model)
-                    settings.agent.chat_model = chat_model
-                    logger.info(f"Chat model configured, using: {provider}:{model}")
-
-        if mcp_hub:
-            for server in mcp_hub:
-                try:
-                    mcp_client = MCPClient(client, server)
-                    toolkit = MCPToolkit(client=mcp_client)
-                    toolkit.initialize()
-                    functions.extend(toolkit.get_tools())
-                except Exception as e:
-                    logger.warn(f"Failed to initialize MCP server {server}: {e!s}")
-
-        if remote_functions:
-            for function in remote_functions:
-                try:
-                    toolkit = RemoteToolkit(client, function)
-                    toolkit.initialize()
-                    functions.extend(toolkit.get_tools())
-                except Exception as e:
-                    logger.warn(f"Failed to initialize remote function {function}: {e!s}")
-
-        if agent.spec.agent_chain:
-            toolkit = ChainToolkit(client, agent.spec.agent_chain)
-            toolkit.initialize()
-            functions.extend(toolkit.get_tools())
-
-        settings.agent.functions = functions
-
-        if override_agent is None and len(functions) == 0:
-            raise ValueError(
-                "You must define at least one function, you can define this function in directory "
-                f'"{settings.agent.functions_directory}". Here is a sample function you can use:\n\n'
-                "from beamlit.functions import function\n\n"
-                "@function()\n"
-                "def hello_world(query: str):\n"
-                "    return 'Hello, world!'\n"
-            )
-
-        if override_agent is None and chat_model is not None:
-            memory = MemorySaver()
-            agent = create_react_agent(chat_model, functions, checkpointer=memory)
-            settings.agent.agent = agent
-        else:
-            settings.agent.agent = override_agent
-        return wrapper
-    except Exception as e:
-        logger.error(f"Error in agent decorator: {e!s} at line {e.__traceback__.tb_lineno}")
-        raise e
+    def wrapper(func: Callable) -> Callable:
+        if bl_kit and not func.__doc__ and bl_kit.description:
+            func.__doc__ = bl_kit.description
+        return func
+
+    return wrapper
+
+
+def function(*args, function: Function | dict = None, kit=False, **kwargs: dict) -> Callable:
+    """Create function tools with Beamlit and LangChain integration."""
+    if function is not None and not isinstance(function, dict):
+        raise Exception(
+            'function must be a dictionary, example: @function(function={"metadata": {"name": "my_function"}})'
+        )
+    if isinstance(function, dict):
+        function = Function(**function)
+
+    def wrapper(func: Callable) -> Callable:
+        if function and not func.__doc__ and function.spec and function.spec.description:
+            func.__doc__ = function.spec.description
+
+        @functools.wraps(func)
+        async def wrapped(*args, **kwargs):
+            if len(args) > 0 and isinstance(args[0], Request):
+                body = await args[0].json()
+                args = [body.get(param) for param in func.__code__.co_varnames[:func.__code__.co_argcount]]
+            return await func(*args, **kwargs) if asyncio.iscoroutinefunction(func) else func(*args, **kwargs)
+        return wrapped
+
+    return wrapper

{beamlit-0.0.34rc61 → beamlit-0.0.34rc63}/src/beamlit/models/__init__.py

@@ -33,7 +33,9 @@ from .function_spec import FunctionSpec
 from .get_trace_ids_response_200 import GetTraceIdsResponse200
 from .get_trace_logs_response_200 import GetTraceLogsResponse200
 from .get_trace_response_200 import GetTraceResponse200
-from .get_workspace_service_accounts_response_200_item import GetWorkspaceServiceAccountsResponse200Item
+from .get_workspace_service_accounts_response_200_item import (
+    GetWorkspaceServiceAccountsResponse200Item,
+)
 from .increase_and_rate_metric import IncreaseAndRateMetric
 from .integration_config import IntegrationConfig
 from .integration_connection import IntegrationConnection

{beamlit-0.0.34rc61 → beamlit-0.0.34rc63}/src/integrationtest/agent.py

@@ -15,6 +15,7 @@ from beamlit.agents import agent
             "model": "gpt-4o-mini",
         },
     },
+    remote_functions=["math"],
 )
 async def main(
     agent, chat_model, tools, body, headers=None, query_params=None, **_

beamlit-0.0.34rc63/src/integrationtest/main.py

@@ -0,0 +1,11 @@
+from beamlit.api.models import list_models
+from beamlit.authentication import new_client
+from beamlit.common.settings import init
+from beamlit.deploy import generate_beamlit_deployment
+
+settings = init()
+client = new_client()
+models = list_models.sync(client=client)
+
+print(models)
+generate_beamlit_deployment(".beamlit")

beamlit-0.0.34rc61/src/beamlit/functions/__init__.py

@@ -1,5 +0,0 @@
-"""Functions package providing function decorators and utilities."""
-
-from .decorator import function, kit
-
-__all__ = ["function", "kit"]

beamlit-0.0.34rc61/src/beamlit/functions/decorator.py

@@ -1,45 +0,0 @@
-"""Decorators for creating function tools with Beamlit and LangChain integration."""
-import asyncio
-import functools
-from collections.abc import Callable
-from logging import getLogger
-
-from fastapi import Request
-
-from beamlit.models import Function, FunctionKit
-
-logger = getLogger(__name__)
-
-def kit(bl_kit: FunctionKit = None, **kwargs: dict) -> Callable:
-    """Create function tools with Beamlit and LangChain integration."""
-
-    def wrapper(func: Callable) -> Callable:
-        if bl_kit and not func.__doc__ and bl_kit.description:
-            func.__doc__ = bl_kit.description
-        return func
-
-    return wrapper
-
-
-def function(*args, function: Function | dict = None, kit=False, **kwargs: dict) -> Callable:
-    """Create function tools with Beamlit and LangChain integration."""
-    if function is not None and not isinstance(function, dict):
-        raise Exception(
-            'function must be a dictionary, example: @function(function={"metadata": {"name": "my_function"}})'
-        )
-    if isinstance(function, dict):
-        function = Function(**function)
-
-    def wrapper(func: Callable) -> Callable:
-        if function and not func.__doc__ and function.spec and function.spec.description:
-            func.__doc__ = function.spec.description
-
-        @functools.wraps(func)
-        async def wrapped(*args, **kwargs):
-            if len(args) > 0 and isinstance(args[0], Request):
-                body = await args[0].json()
-                args = [body.get(param) for param in func.__code__.co_varnames[:func.__code__.co_argcount]]
-            return await func(*args, **kwargs) if asyncio.iscoroutinefunction(func) else func(*args, **kwargs)
-        return wrapped
-
-    return wrapper

beamlit-0.0.34rc61/src/integrationtest/main.py

@@ -1,13 +0,0 @@
-from beamlit.api.models import get_model, list_models
-from beamlit.authentication import get_authentication_headers, new_client
-from beamlit.common.settings import init
-from beamlit.models import Model
-from beamlit.run import RunClient
-from beamlit.deploy import generate_beamlit_deployment
-
-settings = init()
-client = new_client()
-models = list_models.sync(client=client)
-
-print(models)
-generate_beamlit_deployment(".beamlit")