beamlit 0.0.34rc74__tar.gz → 0.0.34rc76__tar.gz

{beamlit-0.0.34rc74 → beamlit-0.0.34rc76}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: beamlit
-Version: 0.0.34rc74
+Version: 0.0.34rc76
 Summary: Add your description here
 Author-email: cploujoux <ch.ploujoux@gmail.com>
 Requires-Python: >=3.12
@@ -21,6 +21,7 @@ Requires-Dist: opentelemetry-instrumentation-system-metrics>=0.50b0
 Requires-Dist: opentelemetry-sdk>=1.28.2
 Requires-Dist: pydantic-settings<2.7.0,>=2.6.1
 Requires-Dist: pydantic<2.11.0,>=2.10.3
+Requires-Dist: pyjwt>=2.10.1
 Requires-Dist: python-dateutil>=2.8.0
 Requires-Dist: pyyaml<6.1.0,>=6.0.2
 Requires-Dist: requests<2.33.0,>=2.32.3

{beamlit-0.0.34rc74 → beamlit-0.0.34rc76}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "beamlit"
-version = "0.0.34.pre-74"
+version = "0.0.34.pre-76"
 description = "Add your description here"
 readme = "README.md"
 authors = [
@@ -33,6 +33,7 @@ dependencies = [
     "opentelemetry-instrumentation-fastapi>=0.49b2",
     "opentelemetry-instrumentation-httpx>=0.49b2",
     "opentelemetry-instrumentation-system-metrics>=0.50b0",
+    "pyjwt>=2.10.1",
 ]
 [dependency-groups]
 dev = [

beamlit-0.0.34rc76/src/beamlit/agents/__init__.py

@@ -0,0 +1,5 @@
+from .chat import get_chat_model
+from .decorator import agent
+from .thread import get_default_thread
+
+__all__ = ["agent", "get_chat_model", "get_default_thread"]

beamlit-0.0.34rc76/src/beamlit/agents/thread.py

@@ -0,0 +1,14 @@
+
+import jwt
+from fastapi import Request
+
+
+def get_default_thread(request: Request) -> str:
+    if request.headers.get("X-Beamlit-Sub"):
+        return request.headers.get("X-Beamlit-Sub")
+    authorization = request.headers.get("Authorization", request.headers.get("X-Beamlit-Authorization"))
+    if authorization and len(authorization.split("Bearer ")) > 1:
+        token = authorization.split(" ")[1]
+        decoded = jwt.decode(token, options={"verify_signature": False})
+        return decoded["sub"]
+    return ""

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

@@ -0,0 +1,193 @@
+"""Decorators for creating function tools with Beamlit and LangChain integration."""
+import ast
+import asyncio
+import functools
+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 langchain_core.tools.base import create_schema_from_function
+
+from beamlit.authentication import new_client
+from beamlit.client import AuthenticatedClient
+from beamlit.common import slugify
+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 AgentChain, Function, FunctionKit
+
+logger = getLogger(__name__)
+
+def get_functions(
+    mcp_hub:Union[list[str], None]=None,
+    remote_functions:Union[list[str], None]=None,
+    client:Union[AuthenticatedClient, None]=None,
+    dir:Union[str, None]=None,
+    chain:Union[list[AgentChain], None]=None,
+    remote_functions_empty:bool=True,
+    from_decorator:str="function",
+    warning:bool=True,
+):
+    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
+
+    functions = []
+    logger = getLogger(__name__)
+    settings = get_settings()
+
+    # Walk through all Python files in functions directory and subdirectories
+    if not os.path.exists(dir):
+        if remote_functions_empty and warning:
+            logger.warn(f"Functions directory {dir} not found")
+    if os.path.exists(dir):
+        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 functions
+                            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
+                                    is_kit = False
+                                    if isinstance(decorator, ast.Call):
+                                        for keyword in decorator.keywords:
+                                            if keyword.arg == "kit" and isinstance(
+                                                keyword.value, ast.Constant
+                                            ):
+                                                is_kit = keyword.value.value
+                                    if is_kit and not settings.remote:
+                                        kit_functions = get_functions(
+                                            client=client,
+                                            dir=os.path.join(root),
+                                            remote_functions_empty=remote_functions_empty,
+                                            from_decorator="kit",
+                                        )
+                                        functions.extend(kit_functions)
+
+                                    # Get the decorated function
+                                    if not is_kit and hasattr(module, func_name):
+                                        func = getattr(module, func_name)
+                                        if settings.remote:
+                                            toolkit = RemoteToolkit(client, slugify(func.__name__))
+                                            toolkit.initialize()
+                                            functions.extend(toolkit.get_tools())
+                                        else:
+                                            if asyncio.iscoroutinefunction(func):
+                                                functions.append(
+                                                    StructuredTool(
+                                                        name=func.__name__,
+                                                        description=func.__doc__,
+                                                        func=func,
+                                                        coroutine=func,
+                                                        args_schema=create_schema_from_function(func.__name__, func)
+                                                    )
+                                                )
+                                            else:
+
+                                                functions.append(
+                                                    StructuredTool(
+                                                        name=func.__name__,
+                                                        description=func.__doc__,
+                                                        func=func,
+                                                        args_schema=create_schema_from_function(func.__name__, func)
+                                                    )
+                                                )
+                        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 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.34rc74 → beamlit-0.0.34rc76}/uv.lock

@@ -176,13 +176,14 @@ dependencies = [
     { name = "opentelemetry-sdk" },
     { name = "pydantic" },
     { name = "pydantic-settings" },
+    { name = "pyjwt" },
     { name = "python-dateutil" },
     { name = "pyyaml" },
     { name = "requests" },
     { name = "traceloop-sdk" },
 ]
 
-[package.dev-dependencies]
+[package.dependency-groups]
 dev = [
     { name = "ruff" },
 ]
@@ -206,13 +207,14 @@ requires-dist = [
     { name = "opentelemetry-sdk", specifier = ">=1.28.2" },
     { name = "pydantic", specifier = ">=2.10.3,<2.11.0" },
     { name = "pydantic-settings", specifier = ">=2.6.1,<2.7.0" },
+    { name = "pyjwt", specifier = ">=2.10.1" },
     { name = "python-dateutil", specifier = ">=2.8.0" },
     { name = "pyyaml", specifier = ">=6.0.2,<6.1.0" },
     { name = "requests", specifier = ">=2.32.3,<2.33.0" },
     { name = "traceloop-sdk", specifier = ">=0.33.12" },
 ]
 
-[package.metadata.requires-dev]
+[package.metadata.dependency-groups]
 dev = [{ name = "ruff", specifier = ">=0.8.2" }]
 
 [[package]]
@@ -1894,6 +1896,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/8a/0b/9fcc47d19c48b59121088dd6da2488a49d5f72dacf8262e2790a1d2c7d15/pygments-2.19.1-py3-none-any.whl", hash = "sha256:9ea1544ad55cecf4b8242fab6dd35a93bbce657034b0611ee383099054ab6d8c", size = 1225293 },
 ]
 
+[[package]]
+name = "pyjwt"
+version = "2.10.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e7/46/bd74733ff231675599650d3e47f361794b22ef3e3770998dda30d3b63726/pyjwt-2.10.1.tar.gz", hash = "sha256:3cc5772eb20009233caf06e9d8a0577824723b44e6648ee0a2aedb6cf9381953", size = 87785 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/61/ad/689f02752eeec26aed679477e80e632ef1b682313be70793d798c1d5fc8f/PyJWT-2.10.1-py3-none-any.whl", hash = "sha256:dcdd193e30abefd5debf142f9adfcdd2b58004e644f25406ffaebd50bd98dacb", size = 22997 },
+]
+
 [[package]]
 name = "python-dateutil"
 version = "2.9.0.post0"

beamlit-0.0.34rc74/src/beamlit/agents/__init__.py

@@ -1,4 +0,0 @@
-from .chat import get_chat_model
-from .decorator import agent
-
-__all__ = ["agent", "get_chat_model"]

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

@@ -1,193 +0,0 @@
-"""Decorators for creating function tools with Beamlit and LangChain integration."""
-import ast
-import asyncio
-import functools
-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 langchain_core.tools.base import create_schema_from_function
-
-from beamlit.authentication import new_client
-from beamlit.client import AuthenticatedClient
-from beamlit.common import slugify
-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 AgentChain, Function, FunctionKit
-
-logger = getLogger(__name__)
-
-def get_functions(
-    mcp_hub:Union[list[str], None]=None,
-    remote_functions:Union[list[str], None]=None,
-    client:Union[AuthenticatedClient, None]=None,
-    dir:Union[str, None]=None,
-    chain:Union[list[AgentChain], None]=None,
-    remote_functions_empty:bool=True,
-    from_decorator:str="function",
-    warning:bool=True,
-):
-    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
-
-    functions = []
-    logger = getLogger(__name__)
-    settings = get_settings()
-
-    # Walk through all Python files in functions directory and subdirectories
-    if not os.path.exists(dir):
-        if remote_functions_empty and warning:
-            logger.warn(f"Functions directory {dir} not found")
-        return []
-    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 functions
-                        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
-                                is_kit = False
-                                if isinstance(decorator, ast.Call):
-                                    for keyword in decorator.keywords:
-                                        if keyword.arg == "kit" and isinstance(
-                                            keyword.value, ast.Constant
-                                        ):
-                                            is_kit = keyword.value.value
-                                if is_kit and not settings.remote:
-                                    kit_functions = get_functions(
-                                        client=client,
-                                        dir=os.path.join(root),
-                                        remote_functions_empty=remote_functions_empty,
-                                        from_decorator="kit",
-                                    )
-                                    functions.extend(kit_functions)
-
-                                # Get the decorated function
-                                if not is_kit and hasattr(module, func_name):
-                                    func = getattr(module, func_name)
-                                    if settings.remote:
-                                        toolkit = RemoteToolkit(client, slugify(func.__name__))
-                                        toolkit.initialize()
-                                        functions.extend(toolkit.get_tools())
-                                    else:
-                                        if asyncio.iscoroutinefunction(func):
-                                            functions.append(
-                                                StructuredTool(
-                                                    name=func.__name__,
-                                                    description=func.__doc__,
-                                                    func=func,
-                                                    coroutine=func,
-                                                    args_schema=create_schema_from_function(func.__name__, func)
-                                                )
-                                            )
-                                        else:
-
-                                            functions.append(
-                                                StructuredTool(
-                                                    name=func.__name__,
-                                                    description=func.__doc__,
-                                                    func=func,
-                                                    args_schema=create_schema_from_function(func.__name__, func)
-                                                )
-                                            )
-                    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 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