beamlit 0.0.33rc49__tar.gz → 0.0.33rc50__tar.gz

{beamlit-0.0.33rc49 → beamlit-0.0.33rc50}/PKG-INFO

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

{beamlit-0.0.33rc49 → beamlit-0.0.33rc50}/pyproject.toml

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

{beamlit-0.0.33rc49 → beamlit-0.0.33rc50}/src/beamlit/common/__init__.py

@@ -1,7 +1,7 @@
 from .error import HTTPError
 from .logger import init as init_logger
 from .secrets import Secret
-from .settings import Settings, get_settings, init, init_agent
+from .settings import Settings, get_settings, init
 from .slugify import slugify
 from .utils import copy_folder
 
@@ -9,7 +9,6 @@ __all__ = [
     "Secret",
     "Settings",
     "get_settings",
-    "init_agent",
     "init",
     "copy_folder",
     "init_logger",

{beamlit-0.0.33rc49 → beamlit-0.0.33rc50}/src/beamlit/common/settings.py

@@ -1,5 +1,4 @@
 import os
-from logging import getLogger
 from typing import Tuple, Type, Union
 
 from langchain_core.language_models.chat_models import BaseChatModel
@@ -12,22 +11,17 @@ from pydantic_settings import (
     YamlConfigSettingsSource,
 )
 
-from beamlit.api.agents import get_agent
-from beamlit.api.functions import get_function
-from beamlit.api.models import get_model
-from beamlit.client import AuthenticatedClient
 from beamlit.common.logger import init as init_logger
 from beamlit.models import Agent, Function, Model
-from beamlit.types import UNSET, Unset
 
 global SETTINGS
 SETTINGS = None
 
 class SettingsAgent(BaseSettings):
-    agent: Union[None, CompiledGraph, BaseChatModel] = None
-    chain: Union[Unset, list[Agent]] = UNSET
-    model: Union[Unset, Model] = UNSET
-    functions: Union[Unset, list[Function]] = UNSET
+    agent: Union[None, CompiledGraph] = None
+    chain: Union[None, list[Agent]] = None
+    model: Union[None, Model] = None
+    functions: Union[None, list[Function]] = None
     functions_directory: str = Field(default="src/functions")
     chat_model: Union[None, BaseChatModel] = None
     module: str = Field(default="main.main")
@@ -100,59 +94,6 @@ class Settings(BaseSettings):
 def get_settings() -> Settings:
     return SETTINGS
 
-
-def init_agent(
-    client: AuthenticatedClient,
-    destination: str = f"{os.getcwd()}/src/beamlit_generated.py",
-):
-    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 = get_agent.sync(name, environment=env, client=client)
-    if not agent:
-        raise ValueError(f"Agent {name} not found")
-    functions: list[Function] = []
-    agents_chain: list[Agent] = []
-    if agent.spec.functions:
-        for function in agent.spec.functions:
-            function = get_function.sync(function, environment=env, client=client)
-            if function:
-                functions.append(function)
-        settings.agent.functions = functions
-
-    if agent.spec.agentChain:
-        for chain in agent.spec.agentChain:
-            if chain.enabled:
-                agentChain = get_agent.sync(chain.name, environment=env, client=client)
-                if chain.description:
-                    agentChain.spec.description = chain.description
-                agents_chain.append(agentChain)
-        settings.agent.chain = agents_chain
-    if agent.spec.model:
-        model = get_model.sync(agent.spec.model, environment=env, client=client)
-        settings.agent.model = model
-
-    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

{beamlit-0.0.33rc49 → beamlit-0.0.33rc50}/src/integrationtest/main.py

@@ -10,7 +10,6 @@ models = list_models.sync(client=client)
 model: Model = get_model.sync(
     "gpt-3-5-turbo", client=client
 )
-# init_agent(client=client)
 run_client = RunClient(client=client)
 response = run_client.run(
     "model",

beamlit-0.0.33rc49/src/beamlit/common/generate.py

@@ -1,196 +0,0 @@
-from typing import Tuple
-
-from beamlit.common.settings import Settings, get_settings
-from beamlit.models import Agent, Function, FunctionMetadata, FunctionSpec
-from beamlit.models.function_kit import FunctionKit
-
-
-def get_titles_name(name: str) -> str:
-    return name.title().replace("-", "").replace("_", "")
-
-
-def generate_kit_function_code(
-    settings: Settings, function: Function, kit: FunctionKit
-) -> Tuple[str, str]:
-    export_code = ""
-    code = ""
-    for kit in kit:
-        fn = Function(
-            metadata=FunctionMetadata(
-                name=kit.name,
-                workspace=settings.workspace,
-                environment=settings.environment,
-            ),
-            spec=FunctionSpec(
-                parameters=kit.parameters,
-                description=kit.description,
-            ),
-        )
-        new_code, export = generate_function_code(
-            settings, fn, force_name_in_endpoint=function.metadata.name, kit=True
-        )
-        code += new_code
-        export_code += export
-    return code, export_code
-
-
-def generate_function_code(
-    settings: Settings,
-    function: Function,
-    force_name_in_endpoint: str = "",
-    kit: bool = False,
-) -> Tuple[str, str]:
-    name = get_titles_name(function.metadata.name)
-    if function.spec.parameters and len(function.spec.parameters) > 0:
-        args_list = ", ".join(f"{param.name}: str" for param in function.spec.parameters)
-        args_list += ", "
-    else:
-        args_list = ""
-    args_schema = ""
-    if function.spec.parameters:
-        for param in function.spec.parameters:
-            args_schema += f'{param.name}: str = Field(description="""{param.description}""")\n    '
-    if len(args_schema) == 0:
-        args_schema = "pass"
-
-    # TODO: add return direct in function configuration
-    return_direct = False
-    endpoint_name = force_name_in_endpoint or function.metadata.name
-    body = "{}"
-    if function.spec.parameters:
-        body = f'{", ".join(f'"{param.name}": {param.name}' for param in function.spec.parameters)}'
-    if kit is True:
-        has_name = False
-        if function.spec.parameters:
-            for param in function.spec.parameters:
-                if param.name == "name":
-                    has_name = True
-                    break
-        if not has_name:
-            if len(body) > 0:
-                body += ", "
-            body += f'"name": "{function.metadata.name}"'
-    return (
-        f'''
-
-class Beamlit{name}Input(BaseModel):
-    {args_schema}
-
-class Beamlit{name}(BaseTool):
-    name: str = "beamlit_{function.metadata.name.replace("-", "_")}"
-    description: str = """{function.spec.description}"""
-    args_schema: Type[BaseModel] = Beamlit{name}Input
-
-    response_format: Literal["content_and_artifact"] = "content_and_artifact"
-    return_direct: bool = {return_direct}
-
-    def _run(self, {args_list} run_manager: Optional[CallbackManagerForToolRun] = None) -> Tuple[Union[List[Dict[str, str]], str], Dict]:
-        try:
-            params = self.metadata.get("params", {{}})
-            response = run_client.run("function", "{endpoint_name}", settings.environment, "POST", json={{{body}}})
-            if response.status_code >= 400:
-                logger.error(f"Failed to run function {name}, {{response.status_code}}::{{response.text}}")
-                raise Exception(f"Failed to run function {name}, {{response.status_code}}::{{response.text}}")
-            return response.json(), {{}}
-        except Exception as e:
-            return repr(e), {{}}
-''',
-        f"Beamlit{get_titles_name(function.metadata.name)},",
-    )
-
-
-def generate_chain_code(settings: Settings, agent: Agent) -> Tuple[str, str]:
-    name = get_titles_name(agent.metadata.name)
-    # TODO: add return direct in agent configuration
-    return_direct = False
-    return (
-        f'''
-class BeamlitChain{name}Input(BaseModel):
-    input: str = Field(description='{agent.spec.description}')
-
-class BeamlitChain{name}(BaseTool):
-    name: str = "beamlit_chain_{agent.metadata.name.replace("-", "_")}"
-    description: str = """{agent.spec.description}"""
-    args_schema: Type[BaseModel] = BeamlitChain{name}Input
-
-    response_format: Literal["content_and_artifact"] = "content_and_artifact"
-    return_direct: bool = {return_direct}
-
-    def _run(
-        self,
-        input: str,
-        run_manager: Optional[CallbackManagerForToolRun] = None,
-    ) -> Tuple[Union[List[Dict[str, str]], str], Dict]:
-        try:
-            params = self.metadata.get("params", {{}})
-            response = run_client.run("agent", "{agent.metadata.name}", settings.environment, "POST", json={{"input": input}})
-            if response.status_code >= 400:
-                logger.error(f"Failed to run tool {agent.metadata.name}, {{response.status_code}}::{{response.text}}")
-                raise Exception(f"Failed to run tool {agent.metadata.name}, {{response.status_code}}::{{response.text}}")
-            if response.headers.get("Content-Type") == "application/json":
-                return response.json(), {{}}
-            else:
-                return response.text, {{}}
-        except Exception as e:
-            return repr(e), {{}}
-''',
-        f"BeamlitChain{name},",
-    )
-
-
-def generate(destination: str, dry_run: bool = False):
-    imports = """from logging import getLogger
-from typing import Dict, List, Literal, Optional, Tuple, Type, Union
-
-from langchain_core.callbacks import CallbackManagerForToolRun
-from langchain_core.tools import BaseTool
-from pydantic import BaseModel, Field
-from beamlit.authentication import (RunClientWithCredentials,
-                                    load_credentials_from_settings,
-                                    new_client_with_credentials)
-from beamlit.common.settings import get_settings
-from beamlit.run import RunClient
-
-logger = getLogger(__name__)
-settings = get_settings()
-credentials = load_credentials_from_settings(settings)
-
-client_config = RunClientWithCredentials(
-    credentials=credentials,
-    workspace=settings.workspace,
-)
-client = new_client_with_credentials(client_config)
-run_client = RunClient(client=client)
-"""
-    settings = get_settings()
-    export_code = "\n\nfunctions = ["
-    export_chain = "\n\nchains = ["
-    code = imports
-    if settings.agent.functions and len(settings.agent.functions) > 0:
-        for function_config in settings.agent.functions:
-            if function_config.spec.kit and len(function_config.spec.kit) > 0:
-                new_code, export = generate_kit_function_code(
-                    settings, function_config, function_config.spec.kit
-                )
-                code += new_code
-                export_code += export
-            else:
-                new_code, export = generate_function_code(settings, function_config)
-                code += new_code
-                export_code += export
-    if settings.agent.chain and len(settings.agent.chain) > 0:
-        for agent in settings.agent.chain:
-            new_code, export = generate_chain_code(settings, agent)
-            code += new_code
-            export_chain += export
-    if settings.agent.functions and len(settings.agent.functions) > 0:
-        export_code = export_code[:-1]
-    export_code += "]"
-    if settings.agent.chain and len(settings.agent.chain) > 0:
-        export_chain = export_chain[:-1]
-    export_chain += "]"
-    content = code + export_code + export_chain
-    if not dry_run:
-        with open(destination, "w") as f:
-            f.write(content)
-    return content