beamlit 0.0.24rc20__py3-none-any.whl → 0.0.25__py3-none-any.whl

beamlit/deploy/parser.py

@@ -0,0 +1,175 @@
+import ast
+import importlib
+import os
+from dataclasses import dataclass
+from logging import getLogger
+from typing import Callable, Literal
+
+from beamlit.models import StoreFunctionParameter
+
+@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} at line {e.__traceback__.tb_lineno}")
+    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 ""

beamlit/functions/decorator.py

@@ -6,22 +6,22 @@ from logging import getLogger
 
 from beamlit.authentication import new_client
 from beamlit.common.settings import get_settings
-from beamlit.models import FunctionDeployment, FunctionKit
+from beamlit.models import Function, FunctionKit
 from beamlit.run import RunClient
 from langchain_core.tools import create_schema_from_function
 
 logger = getLogger(__name__)
 
 
-def get_remote_function(func: Callable, bl_function: FunctionDeployment):
+def get_remote_function(func: Callable, function: Function):
     settings = get_settings()
+    name = (function and function.metadata and function.metadata.name) or func.__name__
 
     def _partial(*args, **kwargs):
         # Get function signature parameters
         try:
             client = new_client()
             run_client = RunClient(client)
-            name = (bl_function and bl_function.function) or func.__name__
             logger.debug(
                 f"Calling remote function: NAME={name}"
                 f" PARAMS={kwargs} ENVIRONMENT={settings.environment}"
@@ -47,7 +47,7 @@ def get_remote_function(func: Callable, bl_function: FunctionDeployment):
                 return response.json()
             return content
         except Exception as e:
-            logger.error(f"Error calling function {bl_function.id}: {e}")
+            logger.error(f"Error calling function {name}: {e}")
             raise e
 
     remote_func = _partial
@@ -67,17 +67,15 @@ def kit(bl_kit: FunctionKit = None, **kwargs: dict) -> Callable:
     return wrapper
 
 
-def function(
-    *args, bl_function: FunctionDeployment = None, kit=False, **kwargs: dict
-) -> Callable:
+def function(*args, function: Function = None, kit=False, **kwargs: dict) -> Callable:
     """Create function tools with Beamlit and LangChain integration."""
     settings = get_settings()
 
     def wrapper(func: Callable) -> Callable:
-        if bl_function and not func.__doc__ and bl_function.description:
-            func.__doc__ = bl_function.description
+        if function and not func.__doc__ and function.spec and function.spec.description:
+            func.__doc__ = function.spec.description
         if settings.remote:
-            remote_func = get_remote_function(func, bl_function)
+            remote_func = get_remote_function(func, function)
             if not kwargs.get("args_schema"):
                 kwargs["args_schema"] = create_schema_from_function(
                     func.__name__,
@@ -88,4 +86,3 @@ def function(
         return func
 
     return wrapper
-    return wrapper

beamlit/models/__init__.py

@@ -3,107 +3,101 @@
 from .acl import ACL
 from .agent import Agent
 from .agent_chain import AgentChain
-from .agent_configuration import AgentConfiguration
-from .agent_deployment import AgentDeployment
-from .agent_deployment_configuration import AgentDeploymentConfiguration
-from .agent_deployment_history import AgentDeploymentHistory
-from .agent_deployment_history_event import AgentDeploymentHistoryEvent
-from .agent_deployment_pod_template import AgentDeploymentPodTemplate
+from .agent_history import AgentHistory
+from .agent_history_event import AgentHistoryEvent
+from .agent_metadata import AgentMetadata
 from .agent_release import AgentRelease
-from .agent_with_deployments import AgentWithDeployments
+from .agent_spec import AgentSpec
 from .api_key import ApiKey
-from .authentication_provider_model import AuthenticationProviderModel
-from .authentication_provider_organization import AuthenticationProviderOrganization
 from .configuration import Configuration
 from .continent import Continent
+from .core_spec import CoreSpec
+from .core_spec_configurations import CoreSpecConfigurations
 from .country import Country
 from .create_api_key_for_service_account_body import CreateApiKeyForServiceAccountBody
 from .create_workspace_service_account_body import CreateWorkspaceServiceAccountBody
 from .create_workspace_service_account_response_200 import CreateWorkspaceServiceAccountResponse200
 from .delete_workspace_service_account_response_200 import DeleteWorkspaceServiceAccountResponse200
-from .deployment_configuration import DeploymentConfiguration
-from .deployment_configurations import DeploymentConfigurations
-from .deployment_serverless_config import DeploymentServerlessConfig
 from .environment import Environment
+from .environment_metadata import EnvironmentMetadata
 from .environment_metrics import EnvironmentMetrics
+from .environment_spec import EnvironmentSpec
 from .flavor import Flavor
 from .function import Function
-from .function_configuration import FunctionConfiguration
-from .function_deployment import FunctionDeployment
-from .function_deployment_configuration import FunctionDeploymentConfiguration
-from .function_deployment_pod_template import FunctionDeploymentPodTemplate
 from .function_kit import FunctionKit
-from .function_provider_ref import FunctionProviderRef
+from .function_metadata import FunctionMetadata
 from .function_release import FunctionRelease
-from .function_with_deployments import FunctionWithDeployments
+from .function_spec import FunctionSpec
 from .get_workspace_service_accounts_response_200_item import GetWorkspaceServiceAccountsResponse200Item
 from .increase_and_rate_metric import IncreaseAndRateMetric
-from .integration import Integration
-from .integration_config import IntegrationConfig
 from .integration_connection import IntegrationConnection
 from .integration_connection_config import IntegrationConnectionConfig
 from .integration_connection_secret import IntegrationConnectionSecret
+from .integration_connection_spec import IntegrationConnectionSpec
 from .integration_model import IntegrationModel
-from .integration_secret import IntegrationSecret
 from .invite_workspace_user_body import InviteWorkspaceUserBody
-from .labels_type_0 import LabelsType0
-from .location import Location
 from .location_response import LocationResponse
+from .metadata import Metadata
+from .metadata_labels import MetadataLabels
 from .metric import Metric
 from .metrics import Metrics
 from .model import Model
-from .model_deployment import ModelDeployment
-from .model_deployment_log import ModelDeploymentLog
-from .model_deployment_metrics import ModelDeploymentMetrics
-from .model_deployment_metrics_inference_per_second_per_region import ModelDeploymentMetricsInferencePerSecondPerRegion
-from .model_deployment_metrics_query_per_second_per_region_per_code import (
-    ModelDeploymentMetricsQueryPerSecondPerRegionPerCode,
-)
-from .model_deployment_pod_template import ModelDeploymentPodTemplate
-from .model_metrics import ModelMetrics
+from .model_metadata import ModelMetadata
+from .model_private_cluster import ModelPrivateCluster
 from .model_provider import ModelProvider
-from .model_provider_ref import ModelProviderRef
 from .model_release import ModelRelease
-from .model_with_deployments import ModelWithDeployments
+from .model_spec import ModelSpec
+from .owner_fields import OwnerFields
 from .pending_invitation import PendingInvitation
 from .pending_invitation_accept import PendingInvitationAccept
 from .pending_invitation_render import PendingInvitationRender
 from .pending_invitation_render_invited_by import PendingInvitationRenderInvitedBy
 from .pending_invitation_render_workspace import PendingInvitationRenderWorkspace
 from .pending_invitation_workspace_details import PendingInvitationWorkspaceDetails
+from .pod_template_spec import PodTemplateSpec
 from .policy import Policy
 from .policy_location import PolicyLocation
+from .policy_spec import PolicySpec
+from .private_cluster import PrivateCluster
+from .private_location import PrivateLocation
 from .provider_config import ProviderConfig
 from .qps import QPS
-from .resource_deployment_log import ResourceDeploymentLog
 from .resource_deployment_metrics import ResourceDeploymentMetrics
-from .resource_deployment_metrics_inference_per_region import ResourceDeploymentMetricsInferencePerRegion
 from .resource_deployment_metrics_inference_per_second_per_region import (
     ResourceDeploymentMetricsInferencePerSecondPerRegion,
 )
-from .resource_deployment_metrics_query_per_region_per_code import ResourceDeploymentMetricsQueryPerRegionPerCode
 from .resource_deployment_metrics_query_per_second_per_region_per_code import (
     ResourceDeploymentMetricsQueryPerSecondPerRegionPerCode,
 )
+from .resource_environment_metrics import ResourceEnvironmentMetrics
+from .resource_environment_metrics_inference_per_region import ResourceEnvironmentMetricsInferencePerRegion
+from .resource_environment_metrics_inference_per_second_per_region import (
+    ResourceEnvironmentMetricsInferencePerSecondPerRegion,
+)
+from .resource_environment_metrics_query_per_region_per_code import ResourceEnvironmentMetricsQueryPerRegionPerCode
+from .resource_environment_metrics_query_per_second_per_region_per_code import (
+    ResourceEnvironmentMetricsQueryPerSecondPerRegionPerCode,
+)
+from .resource_log import ResourceLog
 from .resource_metrics import ResourceMetrics
 from .runtime import Runtime
 from .runtime_readiness_probe import RuntimeReadinessProbe
 from .runtime_resources import RuntimeResources
 from .serverless_config import ServerlessConfig
-from .standard_fields_dynamo_db import StandardFieldsDynamoDb
+from .spec_configuration import SpecConfiguration
 from .store_agent import StoreAgent
-from .store_agent_configuration import StoreAgentConfiguration
 from .store_agent_labels import StoreAgentLabels
 from .store_configuration import StoreConfiguration
 from .store_configuration_option import StoreConfigurationOption
 from .store_function import StoreFunction
-from .store_function_configuration import StoreFunctionConfiguration
 from .store_function_kit import StoreFunctionKit
 from .store_function_labels import StoreFunctionLabels
 from .store_function_parameter import StoreFunctionParameter
+from .time_fields import TimeFields
 from .update_workspace_service_account_body import UpdateWorkspaceServiceAccountBody
 from .update_workspace_service_account_response_200 import UpdateWorkspaceServiceAccountResponse200
 from .update_workspace_user_role_body import UpdateWorkspaceUserRoleBody
+from .websocket_channel import WebsocketChannel
 from .workspace import Workspace
 from .workspace_labels import WorkspaceLabels
 from .workspace_user import WorkspaceUser
@@ -112,101 +106,93 @@ __all__ = (
     "ACL",
     "Agent",
     "AgentChain",
-    "AgentConfiguration",
-    "AgentDeployment",
-    "AgentDeploymentConfiguration",
-    "AgentDeploymentHistory",
-    "AgentDeploymentHistoryEvent",
-    "AgentDeploymentPodTemplate",
+    "AgentHistory",
+    "AgentHistoryEvent",
+    "AgentMetadata",
     "AgentRelease",
-    "AgentWithDeployments",
+    "AgentSpec",
     "ApiKey",
-    "AuthenticationProviderModel",
-    "AuthenticationProviderOrganization",
     "Configuration",
     "Continent",
+    "CoreSpec",
+    "CoreSpecConfigurations",
     "Country",
     "CreateApiKeyForServiceAccountBody",
     "CreateWorkspaceServiceAccountBody",
     "CreateWorkspaceServiceAccountResponse200",
     "DeleteWorkspaceServiceAccountResponse200",
-    "DeploymentConfiguration",
-    "DeploymentConfigurations",
-    "DeploymentServerlessConfig",
     "Environment",
+    "EnvironmentMetadata",
     "EnvironmentMetrics",
+    "EnvironmentSpec",
     "Flavor",
     "Function",
-    "FunctionConfiguration",
-    "FunctionDeployment",
-    "FunctionDeploymentConfiguration",
-    "FunctionDeploymentPodTemplate",
     "FunctionKit",
-    "FunctionProviderRef",
+    "FunctionMetadata",
     "FunctionRelease",
-    "FunctionWithDeployments",
+    "FunctionSpec",
     "GetWorkspaceServiceAccountsResponse200Item",
     "IncreaseAndRateMetric",
-    "Integration",
-    "IntegrationConfig",
     "IntegrationConnection",
     "IntegrationConnectionConfig",
     "IntegrationConnectionSecret",
+    "IntegrationConnectionSpec",
     "IntegrationModel",
-    "IntegrationSecret",
     "InviteWorkspaceUserBody",
-    "LabelsType0",
-    "Location",
     "LocationResponse",
+    "Metadata",
+    "MetadataLabels",
     "Metric",
     "Metrics",
     "Model",
-    "ModelDeployment",
-    "ModelDeploymentLog",
-    "ModelDeploymentMetrics",
-    "ModelDeploymentMetricsInferencePerSecondPerRegion",
-    "ModelDeploymentMetricsQueryPerSecondPerRegionPerCode",
-    "ModelDeploymentPodTemplate",
-    "ModelMetrics",
+    "ModelMetadata",
+    "ModelPrivateCluster",
     "ModelProvider",
-    "ModelProviderRef",
     "ModelRelease",
-    "ModelWithDeployments",
+    "ModelSpec",
+    "OwnerFields",
     "PendingInvitation",
     "PendingInvitationAccept",
     "PendingInvitationRender",
     "PendingInvitationRenderInvitedBy",
     "PendingInvitationRenderWorkspace",
     "PendingInvitationWorkspaceDetails",
+    "PodTemplateSpec",
     "Policy",
     "PolicyLocation",
+    "PolicySpec",
+    "PrivateCluster",
+    "PrivateLocation",
     "ProviderConfig",
     "QPS",
-    "ResourceDeploymentLog",
     "ResourceDeploymentMetrics",
-    "ResourceDeploymentMetricsInferencePerRegion",
     "ResourceDeploymentMetricsInferencePerSecondPerRegion",
-    "ResourceDeploymentMetricsQueryPerRegionPerCode",
     "ResourceDeploymentMetricsQueryPerSecondPerRegionPerCode",
+    "ResourceEnvironmentMetrics",
+    "ResourceEnvironmentMetricsInferencePerRegion",
+    "ResourceEnvironmentMetricsInferencePerSecondPerRegion",
+    "ResourceEnvironmentMetricsQueryPerRegionPerCode",
+    "ResourceEnvironmentMetricsQueryPerSecondPerRegionPerCode",
+    "ResourceLog",
     "ResourceMetrics",
     "Runtime",
     "RuntimeReadinessProbe",
     "RuntimeResources",
     "ServerlessConfig",
-    "StandardFieldsDynamoDb",
+    "SpecConfiguration",
     "StoreAgent",
-    "StoreAgentConfiguration",
     "StoreAgentLabels",
     "StoreConfiguration",
     "StoreConfigurationOption",
     "StoreFunction",
-    "StoreFunctionConfiguration",
     "StoreFunctionKit",
     "StoreFunctionLabels",
     "StoreFunctionParameter",
+    "TimeFields",
     "UpdateWorkspaceServiceAccountBody",
     "UpdateWorkspaceServiceAccountResponse200",
     "UpdateWorkspaceUserRoleBody",
+    "WebsocketChannel",
     "Workspace",
     "WorkspaceLabels",
     "WorkspaceUser",

beamlit/models/acl.py

@@ -14,9 +14,7 @@ class ACL:
 
     Attributes:
         created_at (Union[Unset, str]): The date and time when the resource was created
-        created_by (Union[Unset, str]): The user or service account who created the resource
         updated_at (Union[Unset, str]): The date and time when the resource was updated
-        updated_by (Union[Unset, str]): The user or service account who updated the resource
         id (Union[Unset, str]): ACL id
         resource_id (Union[Unset, str]): Resource ID
         resource_type (Union[Unset, str]): Resource type
@@ -27,9 +25,7 @@ class ACL:
     """
 
     created_at: Union[Unset, str] = UNSET
-    created_by: Union[Unset, str] = UNSET
     updated_at: Union[Unset, str] = UNSET
-    updated_by: Union[Unset, str] = UNSET
     id: Union[Unset, str] = UNSET
     resource_id: Union[Unset, str] = UNSET
     resource_type: Union[Unset, str] = UNSET
@@ -42,12 +38,8 @@ class ACL:
     def to_dict(self) -> dict[str, Any]:
         created_at = self.created_at
 
-        created_by = self.created_by
-
         updated_at = self.updated_at
 
-        updated_by = self.updated_by
-
         id = self.id
 
         resource_id = self.resource_id
@@ -66,13 +58,9 @@ class ACL:
         field_dict.update(self.additional_properties)
         field_dict.update({})
         if created_at is not UNSET:
-            field_dict["created_at"] = created_at
-        if created_by is not UNSET:
-            field_dict["created_by"] = created_by
+            field_dict["createdAt"] = created_at
         if updated_at is not UNSET:
-            field_dict["updated_at"] = updated_at
-        if updated_by is not UNSET:
-            field_dict["updated_by"] = updated_by
+            field_dict["updatedAt"] = updated_at
         if id is not UNSET:
             field_dict["id"] = id
         if resource_id is not UNSET:
@@ -95,13 +83,9 @@ class ACL:
         if not src_dict:
             return None
         d = src_dict.copy()
-        created_at = d.pop("created_at", UNSET)
-
-        created_by = d.pop("created_by", UNSET)
-
-        updated_at = d.pop("updated_at", UNSET)
+        created_at = d.pop("createdAt", UNSET)
 
-        updated_by = d.pop("updated_by", UNSET)
+        updated_at = d.pop("updatedAt", UNSET)
 
         id = d.pop("id", UNSET)
 
@@ -119,9 +103,7 @@ class ACL:
 
         acl = cls(
             created_at=created_at,
-            created_by=created_by,
             updated_at=updated_at,
-            updated_by=updated_by,
             id=id,
             resource_id=resource_id,
             resource_type=resource_type,