beamlit 0.0.19__py3-none-any.whl → 0.0.20__py3-none-any.whl

beamlit/common/secrets.py

@@ -0,0 +1,11 @@
+import os
+
+
+class Secret:
+    @staticmethod
+    def get(name: str):
+        return os.getenv(name, os.getenv(f"bl_{name}"))
+
+    @staticmethod
+    def set(name: str, value: str):
+        os.environ[name] = value

beamlit/common/settings.py

@@ -0,0 +1,156 @@
+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
+from beamlit.common.logger import init as init_logger
+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
+
+global SETTINGS
+SETTINGS = None
+
+
+def get_settings():
+    return SETTINGS
+
+
+class SettingsAgent(BaseSettings):
+    agent: Union[None, CompiledGraph, BaseChatModel] = None
+    chain: Union[Unset, List[AgentDeployment]] = UNSET
+    model: Union[Unset, ModelDeployment] = UNSET
+    functions: Union[Unset, List[FunctionDeployment]] = UNSET
+    functions_directory: str = Field(default="src/functions")
+    chat_model: Union[None, BaseChatModel] = None
+    module: str = Field(default="main.main")
+
+
+class SettingsAuthentication(BaseSettings):
+    api_key: Union[None, str] = None
+    jwt: Union[None, str] = None
+    client_credentials: Union[None, str] = None
+
+
+class SettingsServer(BaseSettings):
+    module: str = Field(default="main.main")
+    port: int = Field(default=80)
+    host: str = Field(default="0.0.0.0")
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(
+        yaml_file="beamlit.yaml",
+        env_prefix="bl_",
+        env_nested_delimiter="_",
+    )
+
+    workspace: str
+    environment: str
+    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")
+    log_level: str = Field(default="INFO")
+    agent: SettingsAgent = SettingsAgent()
+    server: SettingsServer = SettingsServer()
+    authentication: SettingsAuthentication = SettingsAuthentication()
+
+    @classmethod
+    def settings_customise_sources(
+        cls,
+        settings_cls: Type[BaseSettings],
+        init_settings: PydanticBaseSettingsSource,
+        env_settings: PydanticBaseSettingsSource,
+        dotenv_settings: PydanticBaseSettingsSource,
+        file_secret_settings: PydanticBaseSettingsSource,
+    ) -> Tuple[PydanticBaseSettingsSource, ...]:
+        return (
+            env_settings,
+            dotenv_settings,
+            file_secret_settings,
+            YamlConfigSettingsSource(settings_cls),
+            init_settings,
+        )
+
+
+def init_agent(
+    client: AuthenticatedClient,
+    destination: str = f"{os.getcwd()}/src/beamlit_generated.py",
+):
+    from beamlit.api.agents import get_agent_deployment
+    from beamlit.common.generate import generate
+
+    logger = getLogger(__name__)
+    settings = get_settings()
+    # Init configuration from environment variables
+    if settings.agent.functions or settings.agent.chain:
+        return
+
+    # Init configuration from beamlit control plane
+    name = settings.name
+    env = settings.environment
+
+    agent_deployment = get_agent_deployment.sync(name, env, client=client)
+    function_deployments = []
+    agent_chain_deployments = []
+    if agent_deployment.functions:
+        for function in agent_deployment.functions:
+            function_deployment = get_function_deployment.sync(function, env, client=client)
+            function_deployments.append(function_deployment)
+        settings.agent.functions = function_deployments
+
+    if agent_deployment.agent_chain:
+        for chain in agent_deployment.agent_chain:
+            if chain.enabled:
+                agent_deployment = get_agent_deployment.sync(chain.name, env, client=client)
+                if chain.description:
+                    agent_deployment.description = chain.description
+                agent_chain_deployments.append(agent_deployment)
+        settings.agent.chain = agent_chain_deployments
+    if agent_deployment.model:
+        model_deployment = get_model_deployment.sync(agent_deployment.model, env, client=client)
+        settings.agent.model = model_deployment
+
+    content_generate = generate(destination, dry_run=True)
+    compared_content = None
+    if os.path.exists(destination):
+        compared_content = open(destination).read()
+
+    if not os.path.exists(destination) or (
+        compared_content and content_generate != compared_content
+    ):
+        logger.info("Generating agent code")
+        generate(destination)
+
+
+def init() -> Settings:
+    """Parse the beamlit.yaml file to get configurations."""
+    from beamlit.authentication.credentials import current_context
+
+    global SETTINGS
+
+    context = current_context()
+    kwargs = {}
+    if context.workspace:
+        kwargs["workspace"] = context.workspace
+    if context.environment:
+        kwargs["environment"] = context.environment
+
+    SETTINGS = Settings(**kwargs)
+    init_logger(SETTINGS.log_level)
+
+    return SETTINGS

beamlit/common/utils.py

@@ -0,0 +1,15 @@
+import filecmp
+import os
+import shutil
+
+
+def copy_folder(source_folder: str, destination_folder: str):
+    for file in os.listdir(source_folder):
+        if os.path.isdir(f"{source_folder}/{file}"):
+            if not os.path.exists(f"{destination_folder}/{file}"):
+                os.makedirs(f"{destination_folder}/{file}")
+            copy_folder(f"{source_folder}/{file}", f"{destination_folder}/{file}")
+        elif not os.path.exists(f"{destination_folder}/{file}") or not filecmp.cmp(
+            f"{source_folder}/{file}", f"{destination_folder}/{file}"
+        ):
+            shutil.copy(f"{source_folder}/{file}", f"{destination_folder}/{file}")

beamlit/functions/__init__.py

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

beamlit/functions/decorator.py

@@ -0,0 +1,90 @@
+"""Decorators for creating function tools with Beamlit and LangChain integration."""
+
+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
+
+logger = getLogger(__name__)
+
+
+def get_remote_function(func: Callable, bl_function: FunctionDeployment):
+    settings = get_settings()
+
+    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}"
+            )
+            response = run_client.run(
+                resource_type="function",
+                resource_name=name,
+                environment=settings.environment,
+                method="POST",
+                headers={},
+                json=kwargs,
+            )
+            if response.status_code >= 400:
+                content = f"{response.status_code}:{response.text}"
+                return f"Error calling remote function: {content}"
+            logger.debug(
+                f"Response from remote function: NAME={name}"
+                f" RESPONSE={response.json()} ENVIRONMENT={settings.environment}"
+            )
+            return response.json()
+        except Exception as e:
+            logger.error(f"Error calling function {bl_function.id}: {e}")
+            raise e
+
+    remote_func = _partial
+    remote_func.__name__ = func.__name__
+    remote_func.__doc__ = func.__doc__
+    return remote_func
+
+
+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 tool(func, **kwargs)
+
+    return wrapper
+
+
+def function(
+    *args, bl_function: FunctionDeployment = 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 (
+            settings.environment == "development"
+            or settings.environment == "production"
+        ):
+            remote_func = get_remote_function(func, bl_function)
+            if not kwargs.get("args_schema"):
+                kwargs["args_schema"] = create_schema_from_function(
+                    func.__name__,
+                    func,
+                    parse_docstring=func.__doc__,
+                )
+            return tool(remote_func, **kwargs)
+        return tool(func, **kwargs)
+
+    return wrapper
+    return wrapper

beamlit/functions/github/__init__.py

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

beamlit/functions/github/github.py

@@ -0,0 +1,21 @@
+from beamlit.common.secrets import Secret
+
+from . import kit
+
+
+def github(name: str, *args):
+    """This function kit is used to perform actions on Github."""
+    github_token = Secret.get("GITHUB_TOKEN")
+    if not github_token:
+        raise ValueError("github_token missing from configuration.")
+
+    modes = {}
+
+    for func_name in dir(kit):
+        if not func_name.startswith("_"):
+            modes[func_name] = getattr(kit, func_name)
+    if name not in modes:
+        msg = f"Invalid mode: {name}"
+        raise ValueError(msg)
+    return modes[name](*args)
+    return modes[name](*args)

beamlit/functions/github/kit/__init__.py

@@ -0,0 +1,7 @@
+"""Kit for interacting with GitHub."""
+
+from .pull_request import list_open_pull_requests
+
+__all__ = [
+    "list_open_pull_requests",
+]

beamlit/functions/github/kit/pull_request.py

@@ -0,0 +1,51 @@
+"""Functions for interacting with GitHub pull requests."""
+
+from typing import Any
+
+from github import Auth, Github, PullRequest
+from pydash import pick
+
+from beamlit.common.secrets import Secret
+
+
+def list_open_pull_requests(
+    repository: str,
+):
+    """
+    This function will fetch a list of the repository's Pull Requests (PRs).
+    It will return the title, and PR number of 5 PRs.
+    """
+    auth = Auth.Token(Secret.get("GITHUB_TOKEN"))
+    gh = Github(auth=auth)
+    repo = gh.get_repo(repository)
+    return [_format_pull_request(pr) for pr in repo.get_pulls(state="open")[:5]]
+
+
+def _format_pull_request(pr: PullRequest) -> dict[str, Any]:
+    raw_data = pr.raw_data
+    raw_data["reviewers"] = [reviewer["login"] for reviewer in raw_data["requested_reviewers"]]
+    raw_data["assignees"] = [assignee["login"] for assignee in raw_data["assignees"]]
+
+    return pick(
+        raw_data,
+        [
+            "id",
+            "title",
+            "labels",
+            "number",
+            "html_url",
+            "diff_url",
+            "patch_url",
+            "commits",
+            "additions",
+            "deletions",
+            "changed_files",
+            "comments",
+            "state",
+            "user.login",
+            "assignees",
+            "reviewers",
+            "created_at",
+            "updated_at",
+        ],
+    )

beamlit/functions/math/__init__.py

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

beamlit/functions/math/math.py

@@ -0,0 +1,40 @@
+import math as math_operation
+import operator
+
+
+def math(query: str):
+    """A function for performing mathematical calculations.."""
+    safe_dict = {
+        "abs": abs,
+        "round": round,
+        "min": min,
+        "max": max,
+        "pow": math_operation.pow,
+        "sqrt": math_operation.sqrt,
+        "sin": math_operation.sin,
+        "cos": math_operation.cos,
+        "tan": math_operation.tan,
+        "pi": math_operation.pi,
+        "e": math_operation.e,
+    }
+
+    # Add basic arithmetic operators
+    safe_dict.update(
+        {
+            "+": operator.add,
+            "-": operator.sub,
+            "*": operator.mul,
+            "/": operator.truediv,
+            "**": operator.pow,
+            "%": operator.mod,
+        }
+    )
+
+    try:
+        # Replace 'x' with '*'
+        query = query.replace("x", "*")
+
+        # Evaluate the expression in a restricted environment
+        return eval(query, {"__builtins__": {}}, safe_dict)
+    except Exception as e:
+        raise ValueError(f"Invalid expression: {str(e)}")

beamlit/functions/search/__init__.py

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

beamlit/functions/search/search.py

@@ -0,0 +1,15 @@
+from langchain_community.tools.tavily_search.tool import TavilySearchResults
+
+from beamlit.common.secrets import Secret
+
+
+def search(query: str):
+    """
+    A search engine optimized for comprehensive, accurate, and trusted results.
+    Useful for when you need to answer questions about current events.
+    Input should be a search query.
+    """
+    api_key = Secret.get("TAVILY_API_KEY")
+    tavily = TavilySearchResults(api_key=api_key, max_results=2)
+    result = tavily.invoke(input=query)
+    return result

beamlit/models/__init__.py

@@ -10,6 +10,7 @@ from .agent_deployment_history import AgentDeploymentHistory
 from .agent_deployment_history_event import AgentDeploymentHistoryEvent
 from .agent_deployment_pod_template import AgentDeploymentPodTemplate
 from .agent_release import AgentRelease
+from .agent_with_deployments import AgentWithDeployments
 from .api_key import ApiKey
 from .authentication_provider_model import AuthenticationProviderModel
 from .authentication_provider_organization import AuthenticationProviderOrganization
@@ -34,7 +35,16 @@ from .function_deployment_pod_template import FunctionDeploymentPodTemplate
 from .function_kit import FunctionKit
 from .function_provider_ref import FunctionProviderRef
 from .function_release import FunctionRelease
+from .function_with_deployments import FunctionWithDeployments
 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_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
@@ -67,9 +77,11 @@ 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,
 )
@@ -107,6 +119,7 @@ __all__ = (
     "AgentDeploymentHistoryEvent",
     "AgentDeploymentPodTemplate",
     "AgentRelease",
+    "AgentWithDeployments",
     "ApiKey",
     "AuthenticationProviderModel",
     "AuthenticationProviderOrganization",
@@ -131,7 +144,16 @@ __all__ = (
     "FunctionKit",
     "FunctionProviderRef",
     "FunctionRelease",
+    "FunctionWithDeployments",
     "GetWorkspaceServiceAccountsResponse200Item",
+    "IncreaseAndRateMetric",
+    "Integration",
+    "IntegrationConfig",
+    "IntegrationConnection",
+    "IntegrationConnectionConfig",
+    "IntegrationConnectionSecret",
+    "IntegrationModel",
+    "IntegrationSecret",
     "InviteWorkspaceUserBody",
     "LabelsType0",
     "Location",
@@ -162,7 +184,9 @@ __all__ = (
     "QPS",
     "ResourceDeploymentLog",
     "ResourceDeploymentMetrics",
+    "ResourceDeploymentMetricsInferencePerRegion",
     "ResourceDeploymentMetricsInferencePerSecondPerRegion",
+    "ResourceDeploymentMetricsQueryPerRegionPerCode",
     "ResourceDeploymentMetricsQueryPerSecondPerRegionPerCode",
     "ResourceMetrics",
     "Runtime",

beamlit/models/acl.py

@@ -1,4 +1,4 @@
-from typing import Any, Type, TypeVar, Union
+from typing import Any, TypeVar, Union
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
@@ -91,7 +91,9 @@ class ACL:
         return field_dict
 
     @classmethod
-    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        if not src_dict:
+            return None
         d = src_dict.copy()
         created_at = d.pop("created_at", UNSET)
 

beamlit/models/agent.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Any, Dict, Type, TypeVar, Union, cast
+from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
@@ -50,7 +50,7 @@ class Agent:
 
         display_name = self.display_name
 
-        labels: Union[Dict[str, Any], None, Unset]
+        labels: Union[None, Unset, dict[str, Any]]
         if isinstance(self.labels, Unset):
             labels = UNSET
         elif isinstance(self.labels, LabelsType0):
@@ -85,9 +85,11 @@ class Agent:
         return field_dict
 
     @classmethod
-    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
         from ..models.labels_type_0 import LabelsType0
 
+        if not src_dict:
+            return None
         d = src_dict.copy()
         created_at = d.pop("created_at", UNSET)
 

beamlit/models/agent_chain.py

@@ -1,4 +1,4 @@
-from typing import Any, Type, TypeVar, Union
+from typing import Any, TypeVar, Union
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
@@ -43,7 +43,9 @@ class AgentChain:
         return field_dict
 
     @classmethod
-    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        if not src_dict:
+            return None
         d = src_dict.copy()
         description = d.pop("description", UNSET)
 

beamlit/models/agent_configuration.py

@@ -1,4 +1,4 @@
-from typing import Any, Type, TypeVar, Union
+from typing import Any, TypeVar, Union
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
@@ -37,7 +37,9 @@ class AgentConfiguration:
         return field_dict
 
     @classmethod
-    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        if not src_dict:
+            return None
         d = src_dict.copy()
         secret = d.pop("secret", UNSET)