beamlit 0.0.40rc84__py3-none-any.whl → 0.0.41__py3-none-any.whl

beamlit/agents/chat.py

@@ -1,11 +1,12 @@
 from logging import getLogger
 from typing import Tuple, Union
 
+from langchain_core.language_models import BaseChatModel
+
 from beamlit.api.models import get_model
 from beamlit.authentication import get_authentication_headers, new_client
 from beamlit.common.settings import get_settings
 from beamlit.models import Model
-from langchain_core.language_models import BaseChatModel
 
 logger = getLogger(__name__)
 

beamlit/common/settings.py

@@ -4,8 +4,12 @@ from typing import 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 pydantic_settings import (
+    BaseSettings,
+    PydanticBaseSettingsSource,
+    SettingsConfigDict,
+    YamlConfigSettingsSource,
+)
 
 from beamlit.common.logger import init as init_logger
 from beamlit.models import Agent, Function, Model

beamlit/functions/__init__.py

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

beamlit/functions/common.py

@@ -0,0 +1,143 @@
+"""Decorators for creating function tools with Beamlit and LangChain integration."""
+import ast
+import asyncio
+import importlib.util
+import os
+from logging import getLogger
+from typing import Union
+
+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.remote.remote import RemoteToolkit
+from beamlit.models import AgentChain
+
+logger = getLogger(__name__)
+
+def get_functions(
+    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 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
+

beamlit/functions/decorator.py

@@ -1,151 +1,15 @@
 """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.remote.remote import RemoteToolkit
-from beamlit.models import AgentChain, Function, FunctionKit
+from beamlit.models import Function, FunctionKit
 
 logger = getLogger(__name__)
 
-def get_functions(
-    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 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."""
 

beamlit/functions/mcp/mcp.py

@@ -1,5 +1,4 @@
 import asyncio
-import urllib.parse
 import warnings
 from typing import Any, Callable
 

beamlit/functions/remote/remote.py

@@ -7,9 +7,10 @@ import pydantic
 import typing_extensions as t
 from langchain_core.tools.base import BaseTool, ToolException
 
-from beamlit.api.functions import get_function
+from beamlit.api.functions import get_function, list_functions
 from beamlit.authentication.authentication import AuthenticatedClient
 from beamlit.common.settings import get_settings
+from beamlit.errors import UnexpectedStatus
 from beamlit.functions.mcp.mcp import MCPClient, MCPToolkit
 from beamlit.models import Function, StoreFunctionParameter
 from beamlit.run import RunClient
@@ -88,7 +89,22 @@ class RemoteToolkit:
     def initialize(self) -> None:
         """Initialize the session and retrieve tools list"""
         if self._function is None:
-            self._function = get_function.sync_detailed(self.function, client=self.client).parsed
+            try:
+                response = get_function.sync_detailed(self.function, client=self.client)
+                self._function = response.parsed
+            except UnexpectedStatus as e:
+                settings = get_settings()
+                functions = list_functions.sync_detailed(
+                    client=self.client,
+                    environment=settings.environment,
+                ).parsed
+                names = [
+                    f.metadata.name
+                    for f in functions
+                ]
+                raise RuntimeError(
+                    f"error: {e.status_code}. Available functions: {', '.join(names)}"
+                )
 
     @t.override
     def get_tools(self) -> list[BaseTool]:

{beamlit-0.0.40rc84.dist-info → beamlit-0.0.41.dist-info}/METADATA

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

{beamlit-0.0.40rc84.dist-info → beamlit-0.0.41.dist-info}/RECORD

@@ -6,7 +6,7 @@ beamlit/run.py,sha256=HtDYDjD7oVfQ8r3T5_t4qN5UDJOJfsQILi45Z21ArAg,1446
 beamlit/types.py,sha256=E1hhDh_zXfsSQ0NCt9-uw90_Mr5iIlsdfnfvxv5HarU,1005
 beamlit/agents/__init__.py,sha256=bWsFaXUbAps3IsL3Prti89m1s714vICXodbQi77h3vY,206
 beamlit/agents/chain.py,sha256=vfCjiFHuu02uTTGicxMlFzjyICQkIjpXrBGs-7uJEsg,2826
-beamlit/agents/chat.py,sha256=5iv6dM7Xlg2oP2cGgAlpFreJl4P8GZAiN8MM3v0YVYs,4714
+beamlit/agents/chat.py,sha256=6iZuaP25hUvrKdth-6sbtqxkZ1wM0Fv13eRttxNZlIU,4715
 beamlit/agents/decorator.py,sha256=R5evLoproCgYjKXmH-Vq31r6G2lzZvUitXD1NoTflcA,6014
 beamlit/agents/thread.py,sha256=LN5Ss-uOf5_hdB0WV1dqpn-N-pDJB3C2hUvlCzdqtdk,519
 beamlit/api/__init__.py,sha256=zTSiG_ujSjAqWPyc435YXaX9XTlpMjiJWBbV-f-YtdA,45
@@ -135,25 +135,18 @@ beamlit/common/error.py,sha256=f9oJDFxhoHK-vpjxBgEp0NwWIk0N_THPemUI7uQxVzU,270
 beamlit/common/instrumentation.py,sha256=L4Y6Xu7rQwIHngfp-d0LtWxReaPte6rIzykvkDaIyzE,9288
 beamlit/common/logger.py,sha256=nN_dSOl4bs13QU3Rod-w3e3jYOnlSrHx3_bs-ACY6Aw,1115
 beamlit/common/secrets.py,sha256=sid81bOe3LflkMKDHwBsBs9nIju8bp5-v9qU9gkyNMc,212
-beamlit/common/settings.py,sha256=TOHmf9haMq_VUEcbeaWeuS8zRVjLtVdcA0aGhNg32iA,3772
+beamlit/common/settings.py,sha256=C7iZrLLvl6ap5VCVCYOoK20WdSFqacmd6HtaeZ7SF6s,3760
 beamlit/common/slugify.py,sha256=nR29r37IdWS2i44ZC6ZsXRgqKPYmvMGtFQ7BuIQUTlc,90
 beamlit/common/utils.py,sha256=jouz5igBvT37Xn_e94-foCHyQczVim-UzVcoIF6RWJ4,657
 beamlit/deploy/__init__.py,sha256=GS7l7Jtm2yKs7iNLKcfjYO-rAhUzggQ3xiYSf3oxLBY,91
 beamlit/deploy/deploy.py,sha256=J5VvXWeyIyz6CWy2ctld28T7sVfas-kiJZ1nx6Zw7t0,10374
 beamlit/deploy/format.py,sha256=U6UZEFAYLnGJJ7O2YmSdlUUFhnWNGAv6NZ-DW4KTgvI,2049
 beamlit/deploy/parser.py,sha256=Ga0poCZkoRnuTw082QnTcNGCBJncoRAnVsn8-1FsaJE,6907
-beamlit/functions/__init__.py,sha256=NcQPZZNfWhAJ1T1F6Xn21LFPMbZ7aMR2Sve3uZOkBCQ,170
-beamlit/functions/decorator.py,sha256=99oHbss0RZ6Km7Gf62otun1az9waZM0GPaOJvvwbmOI,8541
-beamlit/functions/github/__init__.py,sha256=gYnUkeegukOfbymdabuuJkScvH-_ZJygX05BoqkPn0o,49
-beamlit/functions/github/github.py,sha256=RfzWMT9nwPjsCOJr_-emN7eJHCIt2WsvkT9tq8-HfeA,568
-beamlit/functions/github/kit/__init__.py,sha256=jBwPqZv6C23_utukohxqXZwrlicNlI7PYPUj0Den7Cw,136
-beamlit/functions/github/kit/pull_request.py,sha256=wQVeRBakiqu-2ouflO8p1z7D5u07KNsitwyNRrp0KjM,1357
-beamlit/functions/math/__init__.py,sha256=wie4WME8jT-WpFRrtu-lDlHW31Mg6K2cwstjkUdLF3o,43
-beamlit/functions/math/math.py,sha256=CpoLJGwuvwCPGnVC8k9GYuIyvfUYPDQHKlZg3cx-z-A,1049
-beamlit/functions/mcp/mcp.py,sha256=c7OpmC_zIx1fc2lwoPiyJk_yMyRxWiwCpy9hvRV_C0Y,4080
-beamlit/functions/remote/remote.py,sha256=NldBFEostIX7yLw8ZE12MgVqhVpvKB4Z6FiQUBhPFsc,4207
-beamlit/functions/search/__init__.py,sha256=5NAthQ9PBwrkNg1FpLRx4flauvv0HyWuwaVS589c1Pw,49
-beamlit/functions/search/search.py,sha256=8s9ECltq7YE17j6rTxb12uY2EQY4_eTLHmwlIMThI0w,515
+beamlit/functions/__init__.py,sha256=oejZ6GVd4-2kGKsOwRUq1u2AuSyrrn9kWIuH6WxMqhE,189
+beamlit/functions/common.py,sha256=HbP_F7IYywB2jqxobjkjFqDaIsJXym-HPeOfLzoHSBo,7014
+beamlit/functions/decorator.py,sha256=ZtSQsPLI70WKwi2jPhA7DaqREQUINpqt9BDVugeV_sg,1714
+beamlit/functions/mcp/mcp.py,sha256=JnkeIh9jDyiZstBA0OH57aGx2JjEJ_DPtnM17Xw6ykM,4060
+beamlit/functions/remote/remote.py,sha256=pY7gsmonkH8iN1anscMIWX-tW__OaBw14bodSUy1lCE,4845
 beamlit/models/__init__.py,sha256=DB2EBTVX5lTO7CzXvZaqiPtgc9n8SMPu59zGD5_Vvno,9652
 beamlit/models/acl.py,sha256=tH67gsl_BMaviSbTaaIkO1g9cWZgJ6VgAnYVjQSzGZY,3952
 beamlit/models/agent.py,sha256=w2f_d_nLGVHW7blklH34Nmm2TI3MCoEiQN3HMVga5XI,4002
@@ -285,6 +278,6 @@ beamlit/serve/app.py,sha256=ROS_tb9cO4GvOQKCwloyAzpYraTdIb3oG6sChXikeNw,3285
 beamlit/serve/middlewares/__init__.py,sha256=1dVmnOmhAQWvWktqHkKSIX-YoF6fmMU8xkUQuhg_rJU,148
 beamlit/serve/middlewares/accesslog.py,sha256=Mu4T4_9OvHybjA0ApzZFpgi2C8f3X1NbUk-76v634XM,631
 beamlit/serve/middlewares/processtime.py,sha256=lDAaIasZ4bwvN-HKHvZpaD9r-yrkVNZYx4abvbjbrCg,411
-beamlit-0.0.40rc84.dist-info/METADATA,sha256=IIgQeS831MisY-EbiNZqA54a05M-Cb3h_2LT3dxqT7o,3715
-beamlit-0.0.40rc84.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-beamlit-0.0.40rc84.dist-info/RECORD,,
+beamlit-0.0.41.dist-info/METADATA,sha256=ooEf3PaA3aQv8FjRaaNdt4lKqp5WjfqrghGbxAs6OXU,3711
+beamlit-0.0.41.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+beamlit-0.0.41.dist-info/RECORD,,

beamlit/functions/github/__init__.py

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

beamlit/functions/github/github.py

@@ -1,20 +0,0 @@
-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)

beamlit/functions/github/kit/__init__.py

@@ -1,7 +0,0 @@
-"""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

@@ -1,51 +0,0 @@
-"""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

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

beamlit/functions/math/math.py

@@ -1,40 +0,0 @@
-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

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

beamlit/functions/search/search.py

@@ -1,15 +0,0 @@
-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