beamlit 0.0.56rc106__py3-none-any.whl → 0.0.57__py3-none-any.whl

beamlit/functions/mcp/client.py

@@ -0,0 +1,96 @@
+import logging
+from contextlib import asynccontextmanager
+from typing import Any
+from urllib.parse import urljoin, urlparse
+
+import anyio
+import mcp.types as types
+from anyio.abc import TaskStatus
+from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
+from websockets.client import WebSocketClientProtocol
+from websockets.client import connect as ws_connect
+
+logger = logging.getLogger(__name__)
+
+
+def remove_request_params(url: str) -> str:
+    return urljoin(url, urlparse(url).path)
+
+
+@asynccontextmanager
+async def websocket_client(
+    url: str,
+    headers: dict[str, Any] | None = None,
+    timeout: float = 5,
+):
+    """
+    Client transport for WebSocket.
+
+    The `timeout` parameter controls connection timeout.
+    """
+    read_stream: MemoryObjectReceiveStream[types.JSONRPCMessage | Exception]
+    read_stream_writer: MemoryObjectSendStream[types.JSONRPCMessage | Exception]
+
+    write_stream: MemoryObjectSendStream[types.JSONRPCMessage]
+    write_stream_reader: MemoryObjectReceiveStream[types.JSONRPCMessage]
+
+    read_stream_writer, read_stream = anyio.create_memory_object_stream(0)
+    write_stream, write_stream_reader = anyio.create_memory_object_stream(0)
+
+    async with anyio.create_task_group() as tg:
+        try:
+            # Convert http(s):// to ws(s)://
+            ws_url = url.replace("http://", "ws://").replace("https://", "wss://")
+            logger.debug(f"Connecting to WebSocket endpoint: {remove_request_params(ws_url)}")
+            
+            async with ws_connect(ws_url, extra_headers=headers, open_timeout=timeout) as websocket:
+                logger.debug("WebSocket connection established")
+
+                async def ws_reader(
+                    websocket: WebSocketClientProtocol,
+                    task_status: TaskStatus[None] = anyio.TASK_STATUS_IGNORED,
+                ):
+                    try:
+                        task_status.started()
+                        async for message in websocket:
+                            logger.debug(f"Received WebSocket message: {message}")
+                            try:
+                                parsed_message = types.JSONRPCMessage.model_validate_json(message)
+                                logger.debug(f"Received server message: {parsed_message}")
+                                await read_stream_writer.send(parsed_message)
+                            except Exception as exc:
+                                logger.error(f"Error parsing server message: {exc}")
+                                await read_stream_writer.send(exc)
+                    except Exception as exc:
+                        logger.error(f"Error in ws_reader: {exc}")
+                        await read_stream_writer.send(exc)
+                    finally:
+                        await read_stream_writer.aclose()
+
+                async def ws_writer(websocket: WebSocketClientProtocol):
+                    try:
+                        async with write_stream_reader:
+                            async for message in write_stream_reader:
+                                logger.debug(f"Sending client message: {message}")
+                                await websocket.send(
+                                    message.model_dump_json(
+                                        by_alias=True,
+                                        exclude_none=True,
+                                    )
+                                )
+                                logger.debug("Client message sent successfully")
+                    except Exception as exc:
+                        logger.error(f"Error in ws_writer: {exc}")
+                    finally:
+                        await write_stream.aclose()
+
+                await tg.start(ws_reader, websocket)
+                tg.start_soon(ws_writer, websocket)
+
+                try:
+                    yield read_stream, write_stream
+                finally:
+                    tg.cancel_scope.cancel()
+        finally:
+            await read_stream_writer.aclose()
+            await write_stream.aclose()

beamlit/functions/mcp/mcp.py

@@ -14,11 +14,12 @@ import requests
 import typing_extensions as t
 from langchain_core.tools.base import BaseTool, BaseToolkit, ToolException
 from mcp import ClientSession
-from mcp.client.sse import sse_client
 from mcp.types import CallToolResult, ListToolsResult
 
+from beamlit.authentication import get_authentication_headers
 from beamlit.authentication.authentication import AuthenticatedClient
 from beamlit.common.settings import get_settings
+from beamlit.functions.mcp.client import websocket_client
 
 from .utils import create_schema_model
 
@@ -28,63 +29,67 @@ logger = logging.getLogger(__name__)
 
 
 class MCPClient:
-    def __init__(self, client: AuthenticatedClient, url: str):
+    def __init__(self, client: AuthenticatedClient, url: str, fallback_url: str | None = None):
         self.client = client
         self.url = url
-        self._sse = False
+        self.fallback_url = fallback_url
 
-    async def list_sse_tools(self) -> ListToolsResult:
-        # Create a new context for each SSE connection
+    async def list_ws_tools(self, is_fallback: bool = False) -> ListToolsResult:
+        if is_fallback:
+            url = self.fallback_url
+        else:
+            url = self.url
         try:
-            async with sse_client(f"{self.url}/sse") as (read_stream, write_stream):
-                async with ClientSession(read_stream, write_stream) as session:
-                    await session.initialize()
-                    response = await session.list_tools()
+            async with websocket_client(url, headers=get_authentication_headers(settings)) as (read_stream, write_stream):
+                logger.debug("WebSocket connection established")
+                async with ClientSession(read_stream, write_stream) as client:
+                    await client.initialize()
+                    response = await client.list_tools()
+                    logger.debug(f"WebSocket tools: {response}")
                     return response
-        except Exception:
-            self._sse = False
-            logger.info("SSE not available, trying HTTP")
+        except Exception as e:
+            logger.error(f"Error listing tools: {e}")
+            logger.debug("WebSocket not available, trying HTTP")
             return None  # Signal to list_tools() to try HTTP instead
 
-    def list_tools(self) -> ListToolsResult:
+    async def list_tools(self) -> ListToolsResult:
+        logger.debug(f"Listing tools for {self.url}")
         try:
-            loop = asyncio.get_event_loop()
-            result = loop.run_until_complete(self.list_sse_tools())
-            if result is None:  # SSE failed, try HTTP
-                raise Exception("SSE failed")
-            self._sse = True
+            result = await self.list_ws_tools(is_fallback=False)
             return result
-        except Exception:  # Fallback to HTTP
-            client = self.client.get_httpx_client()
-            response = client.request("GET", f"{self.url}/tools/list")
-            response.raise_for_status()
-            return ListToolsResult(**response.json())
+        except Exception as e: # Fallback to Public endpoint
+            if self.fallback_url:
+                try:
+                    result = await self.list_ws_tools(is_fallback=True)
+                    return result
+                except Exception as e:
+                    raise e
+            else:
+                raise e
+
 
     async def call_tool(
         self,
         tool_name: str,
         arguments: dict[str, Any] = None,
+        is_fallback: bool = False,
     ) -> requests.Response | AsyncIterator[CallToolResult]:
-        if self._sse:
-            async with sse_client(f"{self.url}/sse") as (read_stream, write_stream):
+        if is_fallback:
+            url = self.fallback_url
+        else:
+            url = self.url
+        try:
+            async with websocket_client(url, headers=get_authentication_headers(settings)) as (read_stream, write_stream):
                 async with ClientSession(read_stream, write_stream) as session:
                     await session.initialize()
                     response = await session.call_tool(tool_name, arguments or {})
                     content = pydantic_core.to_json(response).decode()
+                    if response.isError:
+                        raise ToolException(content)
                     return content
-        else: # Fallback to HTTP
-            client = self.client.get_httpx_client()
-            response = client.request(
-                "POST",
-                f"{self.url}/tools/call",
-                json={"name": tool_name, "arguments": arguments},
-            )
-            response.raise_for_status()
-            result = CallToolResult(response.json())
-            if result.isError:
-                raise ToolException(result.content)
-            content = pydantic_core.to_json(result.content).decode()
-            return content
+        except Exception as e:
+            raise e
+
 
 class MCPTool(BaseTool):
     """
@@ -93,7 +98,6 @@ class MCPTool(BaseTool):
     Attributes:
         client (MCPClient): The MCP client instance.
         handle_tool_error (bool | str | Callable[[ToolException], str] | None): Error handling strategy.
-        sse (bool): Whether to use SSE streaming for responses.
     """
 
     client: MCPClient
@@ -109,7 +113,16 @@ class MCPTool(BaseTool):
 
     @t.override
     async def _arun(self, *args: t.Any, **kwargs: t.Any) -> t.Any:
-        return await self.client.call_tool(self.name, arguments=kwargs)
+        try:
+            return await self.client.call_tool(self.name, arguments=kwargs)
+        except Exception as e:
+            if self.client.fallback_url:
+                try:
+                    return await self.client.call_tool(self.name, arguments=kwargs, is_fallback=True) # Fallback to Public endpoint
+                except Exception as e:
+                    raise e
+            else:
+                raise e
 
     @t.override
     @property
@@ -132,14 +145,14 @@ class MCPToolkit(BaseToolkit):
     _tools: ListToolsResult | None = None
     model_config = pydantic.ConfigDict(arbitrary_types_allowed=True)
 
-    def initialize(self) -> None:
+    async def initialize(self) -> None:
         """Initialize the session and retrieve tools list"""
         if self._tools is None:
-            response = self.client.list_tools()
+            response = await self.client.list_tools()
             self._tools = response
 
     @t.override
-    def get_tools(self) -> list[BaseTool]:
+    async def get_tools(self) -> list[BaseTool]:
         if self._tools is None:
             raise RuntimeError("Must initialize the toolkit first")
 

beamlit/functions/remote/remote.py

@@ -80,14 +80,12 @@ class RemoteTool(BaseTool):
 
     @t.override
     async def _arun(self, *args: t.Any, **kwargs: t.Any) -> t.Any:
-        settings = get_settings()
         body = {**kwargs}
         if self.kit:
             body["name"] = self.name
         result = self.client.run(
             "function",
             self.resource_name,
-            settings.environment,
             "POST",
             cloud=self.cloud,
             service_name=self.service_name,
@@ -117,12 +115,11 @@ class RemoteToolkit:
     _service_name: str | None = None
     model_config = pydantic.ConfigDict(arbitrary_types_allowed=True)
 
-    def initialize(self) -> None:
+    async def initialize(self) -> None:
         """Initialize the session and retrieve the remote function details."""
-        settings = get_settings()
         if self._function is None:
             try:
-                response = get_function.sync_detailed(self.function, client=self.client, environment=settings.environment)
+                response = get_function.sync_detailed(self.function, client=self.client)
                 function_name = self.function.upper().replace("-", "_")
                 if os.getenv(f"BL_FUNCTION_{function_name}_SERVICE_NAME"):
                     self._service_name = os.getenv(f"BL_FUNCTION_{function_name}_SERVICE_NAME")
@@ -130,7 +127,6 @@ class RemoteToolkit:
             except UnexpectedStatus as e:
                 functions = list_functions.sync_detailed(
                     client=self.client,
-                    environment=settings.environment,
                 ).parsed
                 names = [
                     f.metadata.name
@@ -140,19 +136,21 @@ class RemoteToolkit:
                     f"error: {e.status_code}. Available functions: {', '.join(names)}"
                 )
 
-    def get_tools(self) -> list[BaseTool]:
+    async def get_tools(self) -> list[BaseTool]:
         settings = get_settings()
         if self._function is None:
             raise RuntimeError("Must initialize the toolkit first")
 
         if self._function.spec.integration_connections:
+            fallback_url = None
             url = f"{settings.run_url}/{settings.workspace}/functions/{self._function.metadata.name}"
             if self._service_name:
+                fallback_url = f"https://{self._service_name}.{settings.run_internal_hostname}"
                 url = f"https://{self._service_name}.{settings.run_internal_hostname}"
-            mcp_client = MCPClient(self.client, url)
-            mcp_toolkit = MCPToolkit(client=mcp_client)
-            mcp_toolkit.initialize()
-            return mcp_toolkit.get_tools()
+            mcp_client = MCPClient(self.client, url, fallback_url)
+            mcp_toolkit = MCPToolkit(client=mcp_client, url=url)
+            await mcp_toolkit.initialize()
+            return await mcp_toolkit.get_tools()
 
         if self._function.spec.kit:
             return [

beamlit/models/__init__.py

@@ -3,11 +3,6 @@
 from .acl import ACL
 from .agent import Agent
 from .agent_chain import AgentChain
-from .agent_history import AgentHistory
-from .agent_history_event import AgentHistoryEvent
-from .agent_information_request import AgentInformationRequest
-from .agent_information_response import AgentInformationResponse
-from .agent_release import AgentRelease
 from .agent_spec import AgentSpec
 from .api_key import ApiKey
 from .configuration import Configuration
@@ -22,10 +17,6 @@ from .create_workspace_service_account_response_200 import CreateWorkspaceServic
 from .delete_workspace_service_account_response_200 import DeleteWorkspaceServiceAccountResponse200
 from .entrypoint import Entrypoint
 from .entrypoint_env import EntrypointEnv
-from .environment import Environment
-from .environment_metadata import EnvironmentMetadata
-from .environment_metrics import EnvironmentMetrics
-from .environment_spec import EnvironmentSpec
 from .flavor import Flavor
 from .form import Form
 from .form_config import FormConfig
@@ -33,7 +24,6 @@ from .form_oauthomitempty import FormOauthomitempty
 from .form_secrets import FormSecrets
 from .function import Function
 from .function_kit import FunctionKit
-from .function_release import FunctionRelease
 from .function_spec import FunctionSpec
 from .get_trace_ids_response_200 import GetTraceIdsResponse200
 from .get_trace_logs_response_200 import GetTraceLogsResponse200
@@ -51,7 +41,6 @@ from .integration_model import IntegrationModel
 from .integration_repository import IntegrationRepository
 from .invite_workspace_user_body import InviteWorkspaceUserBody
 from .knowledgebase import Knowledgebase
-from .knowledgebase_release import KnowledgebaseRelease
 from .knowledgebase_spec import KnowledgebaseSpec
 from .knowledgebase_spec_options import KnowledgebaseSpecOptions
 from .last_n_requests_metric import LastNRequestsMetric
@@ -60,9 +49,6 @@ from .location_response import LocationResponse
 from .mcp_definition import MCPDefinition
 from .mcp_definition_entrypoint import MCPDefinitionEntrypoint
 from .mcp_definition_form import MCPDefinitionForm
-from .mcp_hub_artifact import MCPHubArtifact
-from .mcp_hub_artifact_entrypoint import MCPHubArtifactEntrypoint
-from .mcp_hub_artifact_form import MCPHubArtifactForm
 from .metadata import Metadata
 from .metadata_labels import MetadataLabels
 from .metric import Metric
@@ -72,7 +58,6 @@ from .metrics_request_total_per_code import MetricsRequestTotalPerCode
 from .metrics_rps_per_code import MetricsRpsPerCode
 from .model import Model
 from .model_private_cluster import ModelPrivateCluster
-from .model_release import ModelRelease
 from .model_spec import ModelSpec
 from .o_auth import OAuth
 from .owner_fields import OwnerFields
@@ -102,12 +87,11 @@ from .request_total_by_origin_metric_request_total_by_origin_and_code import (
 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_environment_metrics import ResourceEnvironmentMetrics
-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 .resource_metrics_request_total_per_code import ResourceMetricsRequestTotalPerCode
+from .resource_metrics_rps_per_code import ResourceMetricsRpsPerCode
+from .revision_metadata import RevisionMetadata
 from .runtime import Runtime
 from .runtime_readiness_probe import RuntimeReadinessProbe
 from .runtime_resources import RuntimeResources
@@ -138,11 +122,6 @@ __all__ = (
     "ACL",
     "Agent",
     "AgentChain",
-    "AgentHistory",
-    "AgentHistoryEvent",
-    "AgentInformationRequest",
-    "AgentInformationResponse",
-    "AgentRelease",
     "AgentSpec",
     "ApiKey",
     "Configuration",
@@ -157,10 +136,6 @@ __all__ = (
     "DeleteWorkspaceServiceAccountResponse200",
     "Entrypoint",
     "EntrypointEnv",
-    "Environment",
-    "EnvironmentMetadata",
-    "EnvironmentMetrics",
-    "EnvironmentSpec",
     "Flavor",
     "Form",
     "FormConfig",
@@ -168,7 +143,6 @@ __all__ = (
     "FormSecrets",
     "Function",
     "FunctionKit",
-    "FunctionRelease",
     "FunctionSpec",
     "GetTraceIdsResponse200",
     "GetTraceLogsResponse200",
@@ -184,7 +158,6 @@ __all__ = (
     "IntegrationRepository",
     "InviteWorkspaceUserBody",
     "Knowledgebase",
-    "KnowledgebaseRelease",
     "KnowledgebaseSpec",
     "KnowledgebaseSpecOptions",
     "LastNRequestsMetric",
@@ -193,9 +166,6 @@ __all__ = (
     "MCPDefinition",
     "MCPDefinitionEntrypoint",
     "MCPDefinitionForm",
-    "MCPHubArtifact",
-    "MCPHubArtifactEntrypoint",
-    "MCPHubArtifactForm",
     "Metadata",
     "MetadataLabels",
     "Metric",
@@ -205,7 +175,6 @@ __all__ = (
     "MetricsRpsPerCode",
     "Model",
     "ModelPrivateCluster",
-    "ModelRelease",
     "ModelSpec",
     "OAuth",
     "OwnerFields",
@@ -231,10 +200,11 @@ __all__ = (
     "RequestTotalMetric",
     "RequestTotalMetricRequestTotalPerCode",
     "RequestTotalMetricRpsPerCode",
-    "ResourceEnvironmentMetrics",
-    "ResourceEnvironmentMetricsRequestTotalPerCode",
-    "ResourceEnvironmentMetricsRpsPerCode",
     "ResourceLog",
+    "ResourceMetrics",
+    "ResourceMetricsRequestTotalPerCode",
+    "ResourceMetricsRpsPerCode",
+    "RevisionMetadata",
     "Runtime",
     "RuntimeReadinessProbe",
     "RuntimeResources",

beamlit/models/agent.py

@@ -8,7 +8,7 @@ from ..types import UNSET, Unset
 if TYPE_CHECKING:
     from ..models.agent_spec import AgentSpec
     from ..models.core_event import CoreEvent
-    from ..models.environment_metadata import EnvironmentMetadata
+    from ..models.metadata import Metadata
 
 
 T = TypeVar("T", bound="Agent")
@@ -20,13 +20,13 @@ class Agent:
 
     Attributes:
         events (Union[Unset, list['CoreEvent']]): Core events
-        metadata (Union[Unset, EnvironmentMetadata]): Environment metadata
+        metadata (Union[Unset, Metadata]): Metadata
         spec (Union[Unset, AgentSpec]): Agent specification
         status (Union[Unset, str]): Agent status
     """
 
     events: Union[Unset, list["CoreEvent"]] = UNSET
-    metadata: Union[Unset, "EnvironmentMetadata"] = UNSET
+    metadata: Union[Unset, "Metadata"] = UNSET
     spec: Union[Unset, "AgentSpec"] = UNSET
     status: Union[Unset, str] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
@@ -71,7 +71,7 @@ class Agent:
     def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
         from ..models.agent_spec import AgentSpec
         from ..models.core_event import CoreEvent
-        from ..models.environment_metadata import EnvironmentMetadata
+        from ..models.metadata import Metadata
 
         if not src_dict:
             return None
@@ -84,11 +84,11 @@ class Agent:
             events.append(componentsschemas_core_events_item)
 
         _metadata = d.pop("metadata", UNSET)
-        metadata: Union[Unset, EnvironmentMetadata]
+        metadata: Union[Unset, Metadata]
         if isinstance(_metadata, Unset):
             metadata = UNSET
         else:
-            metadata = EnvironmentMetadata.from_dict(_metadata)
+            metadata = Metadata.from_dict(_metadata)
 
         _spec = d.pop("spec", UNSET)
         spec: Union[Unset, AgentSpec]

beamlit/models/function.py

@@ -7,8 +7,8 @@ from ..types import UNSET, Unset
 
 if TYPE_CHECKING:
     from ..models.core_event import CoreEvent
-    from ..models.environment_metadata import EnvironmentMetadata
     from ..models.function_spec import FunctionSpec
+    from ..models.metadata import Metadata
 
 
 T = TypeVar("T", bound="Function")
@@ -20,13 +20,13 @@ class Function:
 
     Attributes:
         events (Union[Unset, list['CoreEvent']]): Core events
-        metadata (Union[Unset, EnvironmentMetadata]): Environment metadata
+        metadata (Union[Unset, Metadata]): Metadata
         spec (Union[Unset, FunctionSpec]): Function specification
         status (Union[Unset, str]): Function status
     """
 
     events: Union[Unset, list["CoreEvent"]] = UNSET
-    metadata: Union[Unset, "EnvironmentMetadata"] = UNSET
+    metadata: Union[Unset, "Metadata"] = UNSET
     spec: Union[Unset, "FunctionSpec"] = UNSET
     status: Union[Unset, str] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
@@ -70,8 +70,8 @@ class Function:
     @classmethod
     def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
         from ..models.core_event import CoreEvent
-        from ..models.environment_metadata import EnvironmentMetadata
         from ..models.function_spec import FunctionSpec
+        from ..models.metadata import Metadata
 
         if not src_dict:
             return None
@@ -84,11 +84,11 @@ class Function:
             events.append(componentsschemas_core_events_item)
 
         _metadata = d.pop("metadata", UNSET)
-        metadata: Union[Unset, EnvironmentMetadata]
+        metadata: Union[Unset, Metadata]
         if isinstance(_metadata, Unset):
             metadata = UNSET
         else:
-            metadata = EnvironmentMetadata.from_dict(_metadata)
+            metadata = Metadata.from_dict(_metadata)
 
         _spec = d.pop("spec", UNSET)
         spec: Union[Unset, FunctionSpec]

beamlit/models/knowledgebase.py

@@ -7,8 +7,8 @@ from ..types import UNSET, Unset
 
 if TYPE_CHECKING:
     from ..models.core_event import CoreEvent
-    from ..models.environment_metadata import EnvironmentMetadata
     from ..models.knowledgebase_spec import KnowledgebaseSpec
+    from ..models.metadata import Metadata
 
 
 T = TypeVar("T", bound="Knowledgebase")
@@ -20,13 +20,13 @@ class Knowledgebase:
 
     Attributes:
         events (Union[Unset, list['CoreEvent']]): Core events
-        metadata (Union[Unset, EnvironmentMetadata]): Environment metadata
+        metadata (Union[Unset, Metadata]): Metadata
         spec (Union[Unset, KnowledgebaseSpec]): Knowledgebase specification
         status (Union[Unset, str]): Knowledgebase status
     """
 
     events: Union[Unset, list["CoreEvent"]] = UNSET
-    metadata: Union[Unset, "EnvironmentMetadata"] = UNSET
+    metadata: Union[Unset, "Metadata"] = UNSET
     spec: Union[Unset, "KnowledgebaseSpec"] = UNSET
     status: Union[Unset, str] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
@@ -70,8 +70,8 @@ class Knowledgebase:
     @classmethod
     def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
         from ..models.core_event import CoreEvent
-        from ..models.environment_metadata import EnvironmentMetadata
         from ..models.knowledgebase_spec import KnowledgebaseSpec
+        from ..models.metadata import Metadata
 
         if not src_dict:
             return None
@@ -84,11 +84,11 @@ class Knowledgebase:
             events.append(componentsschemas_core_events_item)
 
         _metadata = d.pop("metadata", UNSET)
-        metadata: Union[Unset, EnvironmentMetadata]
+        metadata: Union[Unset, Metadata]
         if isinstance(_metadata, Unset):
             metadata = UNSET
         else:
-            metadata = EnvironmentMetadata.from_dict(_metadata)
+            metadata = Metadata.from_dict(_metadata)
 
         _spec = d.pop("spec", UNSET)
         spec: Union[Unset, KnowledgebaseSpec]

beamlit/models/last_n_requests_metric.py

@@ -14,13 +14,11 @@ class LastNRequestsMetric:
 
     Attributes:
         date (Union[Unset, str]): Timestamp
-        environment (Union[Unset, str]): Environment
         workload_type (Union[Unset, str]): Workload type
         workspace (Union[Unset, str]): Workspace
     """
 
     date: Union[Unset, str] = UNSET
-    environment: Union[Unset, str] = UNSET
     workload_type: Union[Unset, str] = UNSET
     workspace: Union[Unset, str] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
@@ -28,8 +26,6 @@ class LastNRequestsMetric:
     def to_dict(self) -> dict[str, Any]:
         date = self.date
 
-        environment = self.environment
-
         workload_type = self.workload_type
 
         workspace = self.workspace
@@ -39,8 +35,6 @@ class LastNRequestsMetric:
         field_dict.update({})
         if date is not UNSET:
             field_dict["date"] = date
-        if environment is not UNSET:
-            field_dict["environment"] = environment
         if workload_type is not UNSET:
             field_dict["workloadType"] = workload_type
         if workspace is not UNSET:
@@ -55,15 +49,12 @@ class LastNRequestsMetric:
         d = src_dict.copy()
         date = d.pop("date", UNSET)
 
-        environment = d.pop("environment", UNSET)
-
         workload_type = d.pop("workloadType", UNSET)
 
         workspace = d.pop("workspace", UNSET)
 
         last_n_requests_metric = cls(
             date=date,
-            environment=environment,
             workload_type=workload_type,
             workspace=workspace,
         )