beamlit 0.0.33rc49__py3-none-any.whl → 0.0.34__py3-none-any.whl

beamlit/functions/decorator.py

@@ -1,15 +1,163 @@
 """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.models import Function, FunctionKit
+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."""
 

beamlit/functions/github/github.py

@@ -18,4 +18,3 @@ def github(name: str, *args):
         msg = f"Invalid mode: {name}"
         raise ValueError(msg)
     return modes[name](*args)
-    return modes[name](*args)

beamlit/models/__init__.py

@@ -11,9 +11,9 @@ from .agent_spec import AgentSpec
 from .api_key import ApiKey
 from .configuration import Configuration
 from .continent import Continent
+from .core_event import CoreEvent
 from .core_spec import CoreSpec
 from .core_spec_configurations import CoreSpecConfigurations
-from .core_status import CoreStatus
 from .country import Country
 from .create_api_key_for_service_account_body import CreateApiKeyForServiceAccountBody
 from .create_workspace_service_account_body import CreateWorkspaceServiceAccountBody
@@ -35,6 +35,8 @@ from .get_trace_response_200 import GetTraceResponse200
 from .get_workspace_service_accounts_response_200_item import (
     GetWorkspaceServiceAccountsResponse200Item,
 )
+from .histogram_bucket import HistogramBucket
+from .histogram_stats import HistogramStats
 from .increase_and_rate_metric import IncreaseAndRateMetric
 from .integration_config import IntegrationConfig
 from .integration_connection import IntegrationConnection
@@ -42,16 +44,21 @@ 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_repository import IntegrationRepository
 from .invite_workspace_user_body import InviteWorkspaceUserBody
+from .last_n_requests_metric import LastNRequestsMetric
+from .latency_metric import LatencyMetric
 from .location_response import LocationResponse
 from .metadata import Metadata
 from .metadata_labels import MetadataLabels
 from .metric import Metric
 from .metrics import Metrics
+from .metrics_models import MetricsModels
+from .metrics_request_total_per_code import MetricsRequestTotalPerCode
+from .metrics_rps_per_code import MetricsRpsPerCode
 from .model import Model
 from .model_metadata import ModelMetadata
 from .model_private_cluster import ModelPrivateCluster
-from .model_provider import ModelProvider
 from .model_release import ModelRelease
 from .model_spec import ModelSpec
 from .owner_fields import OwnerFields
@@ -69,6 +76,19 @@ from .private_cluster import PrivateCluster
 from .private_location import PrivateLocation
 from .provider_config import ProviderConfig
 from .qps import QPS
+from .repository import Repository
+from .request_duration_over_time_metric import RequestDurationOverTimeMetric
+from .request_duration_over_time_metrics import RequestDurationOverTimeMetrics
+from .request_total_by_origin_metric import RequestTotalByOriginMetric
+from .request_total_by_origin_metric_request_total_by_origin import (
+    RequestTotalByOriginMetricRequestTotalByOrigin,
+)
+from .request_total_by_origin_metric_request_total_by_origin_and_code import (
+    RequestTotalByOriginMetricRequestTotalByOriginAndCode,
+)
+from .request_total_metric import RequestTotalMetric
+from .request_total_metric_request_total_per_code import RequestTotalMetricRequestTotalPerCode
+from .request_total_metric_rps_per_code import RequestTotalMetricRpsPerCode
 from .resource_deployment_metrics import ResourceDeploymentMetrics
 from .resource_deployment_metrics_inference_per_second_per_region import (
     ResourceDeploymentMetricsInferencePerSecondPerRegion,
@@ -77,12 +97,10 @@ 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_query_per_region_per_code import (
-    ResourceEnvironmentMetricsQueryPerRegionPerCode,
+from .resource_environment_metrics_request_total_per_code import (
+    ResourceEnvironmentMetricsRequestTotalPerCode,
 )
+from .resource_environment_metrics_rps_per_code import ResourceEnvironmentMetricsRpsPerCode
 from .resource_log import ResourceLog
 from .resource_metrics import ResourceMetrics
 from .runtime import Runtime
@@ -99,6 +117,9 @@ from .store_function_kit import StoreFunctionKit
 from .store_function_labels import StoreFunctionLabels
 from .store_function_parameter import StoreFunctionParameter
 from .time_fields import TimeFields
+from .token_rate_metric import TokenRateMetric
+from .token_rate_metrics import TokenRateMetrics
+from .token_total_metric import TokenTotalMetric
 from .trace_ids_response import TraceIdsResponse
 from .update_workspace_service_account_body import UpdateWorkspaceServiceAccountBody
 from .update_workspace_service_account_response_200 import UpdateWorkspaceServiceAccountResponse200
@@ -120,9 +141,9 @@ __all__ = (
     "ApiKey",
     "Configuration",
     "Continent",
+    "CoreEvent",
     "CoreSpec",
     "CoreSpecConfigurations",
-    "CoreStatus",
     "Country",
     "CreateApiKeyForServiceAccountBody",
     "CreateWorkspaceServiceAccountBody",
@@ -142,6 +163,8 @@ __all__ = (
     "GetTraceLogsResponse200",
     "GetTraceResponse200",
     "GetWorkspaceServiceAccountsResponse200Item",
+    "HistogramBucket",
+    "HistogramStats",
     "IncreaseAndRateMetric",
     "IntegrationConfig",
     "IntegrationConnection",
@@ -149,16 +172,21 @@ __all__ = (
     "IntegrationConnectionSecret",
     "IntegrationConnectionSpec",
     "IntegrationModel",
+    "IntegrationRepository",
     "InviteWorkspaceUserBody",
+    "LastNRequestsMetric",
+    "LatencyMetric",
     "LocationResponse",
     "Metadata",
     "MetadataLabels",
     "Metric",
     "Metrics",
+    "MetricsModels",
+    "MetricsRequestTotalPerCode",
+    "MetricsRpsPerCode",
     "Model",
     "ModelMetadata",
     "ModelPrivateCluster",
-    "ModelProvider",
     "ModelRelease",
     "ModelSpec",
     "OwnerFields",
@@ -176,12 +204,21 @@ __all__ = (
     "PrivateLocation",
     "ProviderConfig",
     "QPS",
+    "Repository",
+    "RequestDurationOverTimeMetric",
+    "RequestDurationOverTimeMetrics",
+    "RequestTotalByOriginMetric",
+    "RequestTotalByOriginMetricRequestTotalByOrigin",
+    "RequestTotalByOriginMetricRequestTotalByOriginAndCode",
+    "RequestTotalMetric",
+    "RequestTotalMetricRequestTotalPerCode",
+    "RequestTotalMetricRpsPerCode",
     "ResourceDeploymentMetrics",
     "ResourceDeploymentMetricsInferencePerSecondPerRegion",
     "ResourceDeploymentMetricsQueryPerSecondPerRegionPerCode",
     "ResourceEnvironmentMetrics",
-    "ResourceEnvironmentMetricsInferencePerRegion",
-    "ResourceEnvironmentMetricsQueryPerRegionPerCode",
+    "ResourceEnvironmentMetricsRequestTotalPerCode",
+    "ResourceEnvironmentMetricsRpsPerCode",
     "ResourceLog",
     "ResourceMetrics",
     "Runtime",
@@ -198,6 +235,9 @@ __all__ = (
     "StoreFunctionLabels",
     "StoreFunctionParameter",
     "TimeFields",
+    "TokenRateMetric",
+    "TokenRateMetrics",
+    "TokenTotalMetric",
     "TraceIdsResponse",
     "UpdateWorkspaceServiceAccountBody",
     "UpdateWorkspaceServiceAccountResponse200",

beamlit/models/agent.py

@@ -7,7 +7,7 @@ from ..types import UNSET, Unset
 
 if TYPE_CHECKING:
     from ..models.agent_spec import AgentSpec
-    from ..models.core_status import CoreStatus
+    from ..models.core_event import CoreEvent
     from ..models.environment_metadata import EnvironmentMetadata
 
 
@@ -19,32 +19,41 @@ class Agent:
     """Agent
 
     Attributes:
+        events (Union[Unset, list['CoreEvent']]): Core events
         metadata (Union[Unset, EnvironmentMetadata]): Environment metadata
         spec (Union[Unset, AgentSpec]): Agent specification
-        status (Union[Unset, CoreStatus]): Core status
+        status (Union[Unset, str]): Agent status
     """
 
+    events: Union[Unset, list["CoreEvent"]] = UNSET
     metadata: Union[Unset, "EnvironmentMetadata"] = UNSET
     spec: Union[Unset, "AgentSpec"] = UNSET
-    status: Union[Unset, "CoreStatus"] = UNSET
+    status: Union[Unset, str] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
+        events: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.events, Unset):
+            events = []
+            for componentsschemas_core_events_item_data in self.events:
+                componentsschemas_core_events_item = componentsschemas_core_events_item_data.to_dict()
+                events.append(componentsschemas_core_events_item)
+
         metadata: Union[Unset, dict[str, Any]] = UNSET
-        if not isinstance(self.metadata, Unset):
+        if self.metadata and not isinstance(self.metadata, Unset):
             metadata = self.metadata.to_dict()
 
         spec: Union[Unset, dict[str, Any]] = UNSET
-        if not isinstance(self.spec, Unset):
+        if self.spec and not isinstance(self.spec, Unset):
             spec = self.spec.to_dict()
 
-        status: Union[Unset, dict[str, Any]] = UNSET
-        if not isinstance(self.status, Unset):
-            status = self.status.to_dict()
+        status = self.status
 
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update({})
+        if events is not UNSET:
+            field_dict["events"] = events
         if metadata is not UNSET:
             field_dict["metadata"] = metadata
         if spec is not UNSET:
@@ -57,12 +66,19 @@ class Agent:
     @classmethod
     def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
         from ..models.agent_spec import AgentSpec
-        from ..models.core_status import CoreStatus
+        from ..models.core_event import CoreEvent
         from ..models.environment_metadata import EnvironmentMetadata
 
         if not src_dict:
             return None
         d = src_dict.copy()
+        events = []
+        _events = d.pop("events", UNSET)
+        for componentsschemas_core_events_item_data in _events or []:
+            componentsschemas_core_events_item = CoreEvent.from_dict(componentsschemas_core_events_item_data)
+
+            events.append(componentsschemas_core_events_item)
+
         _metadata = d.pop("metadata", UNSET)
         metadata: Union[Unset, EnvironmentMetadata]
         if isinstance(_metadata, Unset):
@@ -77,14 +93,10 @@ class Agent:
         else:
             spec = AgentSpec.from_dict(_spec)
 
-        _status = d.pop("status", UNSET)
-        status: Union[Unset, CoreStatus]
-        if isinstance(_status, Unset):
-            status = UNSET
-        else:
-            status = CoreStatus.from_dict(_status)
+        status = d.pop("status", UNSET)
 
         agent = cls(
+            events=events,
             metadata=metadata,
             spec=spec,
             status=status,

beamlit/models/agent_metadata.py

@@ -51,7 +51,7 @@ class AgentMetadata:
         display_name = self.display_name
 
         labels: Union[Unset, dict[str, Any]] = UNSET
-        if not isinstance(self.labels, Unset):
+        if self.labels and not isinstance(self.labels, Unset):
             labels = self.labels.to_dict()
 
         name = self.name

beamlit/models/agent_render.py

@@ -0,0 +1,45 @@
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="AgentRender")
+
+
+@_attrs_define
+class AgentRender:
+    """AgentRender"""
+
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        agent_render = cls()
+
+        agent_render.additional_properties = d
+        return agent_render
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

beamlit/models/agent_spec.py

@@ -11,6 +11,7 @@ if TYPE_CHECKING:
     from ..models.flavor import Flavor
     from ..models.model_private_cluster import ModelPrivateCluster
     from ..models.pod_template_spec import PodTemplateSpec
+    from ..models.repository import Repository
     from ..models.runtime import Runtime
     from ..models.serverless_config import ServerlessConfig
 
@@ -31,11 +32,13 @@ class AgentSpec:
         policies (Union[Unset, list[str]]):
         private_clusters (Union[Unset, ModelPrivateCluster]): Private cluster where the model deployment is deployed
         runtime (Union[Unset, Runtime]): Set of configurations for a deployment
+        sandbox (Union[Unset, bool]): Sandbox mode
         serverless_config (Union[Unset, ServerlessConfig]): Configuration for a serverless deployment
         agent_chain (Union[Unset, list['AgentChain']]): Agent chain
         description (Union[Unset, str]): Agent description
         functions (Union[Unset, list[str]]):
         model (Union[Unset, str]): Model name
+        repository (Union[Unset, Repository]): Repository
         store_id (Union[Unset, str]): Store id
     """
 
@@ -47,17 +50,19 @@ class AgentSpec:
     policies: Union[Unset, list[str]] = UNSET
     private_clusters: Union[Unset, "ModelPrivateCluster"] = UNSET
     runtime: Union[Unset, "Runtime"] = UNSET
+    sandbox: Union[Unset, bool] = UNSET
     serverless_config: Union[Unset, "ServerlessConfig"] = UNSET
     agent_chain: Union[Unset, list["AgentChain"]] = UNSET
     description: Union[Unset, str] = UNSET
     functions: Union[Unset, list[str]] = UNSET
     model: Union[Unset, str] = UNSET
+    repository: Union[Unset, "Repository"] = UNSET
     store_id: Union[Unset, str] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
         configurations: Union[Unset, dict[str, Any]] = UNSET
-        if not isinstance(self.configurations, Unset):
+        if self.configurations and not isinstance(self.configurations, Unset):
             configurations = self.configurations.to_dict()
 
         enabled = self.enabled
@@ -74,7 +79,7 @@ class AgentSpec:
             integration_connections = self.integration_connections
 
         pod_template: Union[Unset, dict[str, Any]] = UNSET
-        if not isinstance(self.pod_template, Unset):
+        if self.pod_template and not isinstance(self.pod_template, Unset):
             pod_template = self.pod_template.to_dict()
 
         policies: Union[Unset, list[str]] = UNSET
@@ -82,15 +87,17 @@ class AgentSpec:
             policies = self.policies
 
         private_clusters: Union[Unset, dict[str, Any]] = UNSET
-        if not isinstance(self.private_clusters, Unset):
+        if self.private_clusters and not isinstance(self.private_clusters, Unset):
             private_clusters = self.private_clusters.to_dict()
 
         runtime: Union[Unset, dict[str, Any]] = UNSET
-        if not isinstance(self.runtime, Unset):
+        if self.runtime and not isinstance(self.runtime, Unset):
             runtime = self.runtime.to_dict()
 
+        sandbox = self.sandbox
+
         serverless_config: Union[Unset, dict[str, Any]] = UNSET
-        if not isinstance(self.serverless_config, Unset):
+        if self.serverless_config and not isinstance(self.serverless_config, Unset):
             serverless_config = self.serverless_config.to_dict()
 
         agent_chain: Union[Unset, list[dict[str, Any]]] = UNSET
@@ -108,6 +115,10 @@ class AgentSpec:
 
         model = self.model
 
+        repository: Union[Unset, dict[str, Any]] = UNSET
+        if self.repository and not isinstance(self.repository, Unset):
+            repository = self.repository.to_dict()
+
         store_id = self.store_id
 
         field_dict: dict[str, Any] = {}
@@ -129,6 +140,8 @@ class AgentSpec:
             field_dict["privateClusters"] = private_clusters
         if runtime is not UNSET:
             field_dict["runtime"] = runtime
+        if sandbox is not UNSET:
+            field_dict["sandbox"] = sandbox
         if serverless_config is not UNSET:
             field_dict["serverlessConfig"] = serverless_config
         if agent_chain is not UNSET:
@@ -139,6 +152,8 @@ class AgentSpec:
             field_dict["functions"] = functions
         if model is not UNSET:
             field_dict["model"] = model
+        if repository is not UNSET:
+            field_dict["repository"] = repository
         if store_id is not UNSET:
             field_dict["storeId"] = store_id
 
@@ -151,6 +166,7 @@ class AgentSpec:
         from ..models.flavor import Flavor
         from ..models.model_private_cluster import ModelPrivateCluster
         from ..models.pod_template_spec import PodTemplateSpec
+        from ..models.repository import Repository
         from ..models.runtime import Runtime
         from ..models.serverless_config import ServerlessConfig
 
@@ -198,6 +214,8 @@ class AgentSpec:
         else:
             runtime = Runtime.from_dict(_runtime)
 
+        sandbox = d.pop("sandbox", UNSET)
+
         _serverless_config = d.pop("serverlessConfig", UNSET)
         serverless_config: Union[Unset, ServerlessConfig]
         if isinstance(_serverless_config, Unset):
@@ -218,6 +236,13 @@ class AgentSpec:
 
         model = d.pop("model", UNSET)
 
+        _repository = d.pop("repository", UNSET)
+        repository: Union[Unset, Repository]
+        if isinstance(_repository, Unset):
+            repository = UNSET
+        else:
+            repository = Repository.from_dict(_repository)
+
         store_id = d.pop("storeId", UNSET)
 
         agent_spec = cls(
@@ -229,11 +254,13 @@ class AgentSpec:
             policies=policies,
             private_clusters=private_clusters,
             runtime=runtime,
+            sandbox=sandbox,
             serverless_config=serverless_config,
             agent_chain=agent_chain,
             description=description,
             functions=functions,
             model=model,
+            repository=repository,
             store_id=store_id,
         )