dagster-cloud 1.12.11__py3-none-any.whl → 1.12.13__py3-none-any.whl

dagster_cloud/agent/dagster_cloud_agent.py

@@ -32,10 +32,6 @@ from dagster_cloud_cli.core.errors import DagsterCloudHTTPError, raise_http_erro
 from dagster_cloud_cli.core.workspace import CodeLocationDeployData
 from dagster_shared.record import replace
 
-from dagster_cloud.agent.instrumentation.constants import DAGSTER_CLOUD_AGENT_METRIC_PREFIX
-from dagster_cloud.agent.instrumentation.run_launch import extract_run_attributes
-from dagster_cloud.agent.instrumentation.schedule import inspect_schedule_result
-from dagster_cloud.agent.instrumentation.sensor import inspect_sensor_result
 from dagster_cloud.agent.queries import (
     ADD_AGENT_HEARTBEATS_MUTATION,
     DEPLOYMENTS_QUERY,
@@ -59,7 +55,6 @@ from dagster_cloud.api.dagster_cloud_api import (
 )
 from dagster_cloud.batching import Batcher
 from dagster_cloud.instance import DagsterCloudAgentInstance
-from dagster_cloud.opentelemetry.observers.execution_observer import observe_execution
 from dagster_cloud.util import SERVER_HANDLE_TAG, compressed_namedtuple_upload_file, is_isolated_run
 from dagster_cloud.version import __version__
 from dagster_cloud.workspace.user_code_launcher import (
@@ -981,29 +976,12 @@ class DagsterCloudAgent:
                 instance_ref=self._get_user_code_instance_ref(deployment_name),
             )
 
-            schedule_attributes = {
-                "schedule": args.schedule_name,
-                "repository": args.repository_origin.repository_name,
-                "location": args.repository_origin.code_location_origin.location_name,
-                "deployment": deployment_name,
-            }
-
-            with observe_execution(
-                opentelemetry=self._instance.opentelemetry,
-                event_key=f"{DAGSTER_CLOUD_AGENT_METRIC_PREFIX}.schedule.evaluation",
-                short_description="schedule evaluation requests",
-                attributes=schedule_attributes,
-                result_evaluator_callback=inspect_schedule_result,
-            ) as observer:
-                serialized_schedule_data_or_error = client.external_schedule_execution(
-                    external_schedule_execution_args=args,
-                )
-                observer.evaluate_result(
-                    serialized_data_or_error=serialized_schedule_data_or_error,
-                )
-                return DagsterCloudApiGrpcResponse(
-                    serialized_response_or_error=serialized_schedule_data_or_error
-                )
+            serialized_schedule_data_or_error = client.external_schedule_execution(
+                external_schedule_execution_args=args,
+            )
+            return DagsterCloudApiGrpcResponse(
+                serialized_response_or_error=serialized_schedule_data_or_error
+            )
 
         elif api_name == DagsterCloudApi.GET_EXTERNAL_SENSOR_EXECUTION_DATA:
             client = self._get_grpc_client(
@@ -1015,27 +993,12 @@ class DagsterCloudAgent:
                 instance_ref=self._get_user_code_instance_ref(deployment_name),
             )
 
-            sensor_attributes = {
-                "sensor": args.sensor_name,
-                "repository": args.repository_origin.repository_name,
-                "location": args.repository_origin.code_location_origin.location_name,
-                "deployment": deployment_name,
-            }
-
-            with observe_execution(
-                opentelemetry=self._instance.opentelemetry,
-                event_key=f"{DAGSTER_CLOUD_AGENT_METRIC_PREFIX}.sensor.evaluation",
-                short_description="sensor evaluation requests",
-                attributes=sensor_attributes,
-                result_evaluator_callback=inspect_sensor_result,
-            ) as observer:
-                serialized_sensor_data_or_error = client.external_sensor_execution(
-                    sensor_execution_args=args,
-                )
-                observer.evaluate_result(serialized_sensor_data_or_error)
-                return DagsterCloudApiGrpcResponse(
-                    serialized_response_or_error=serialized_sensor_data_or_error
-                )
+            serialized_sensor_data_or_error = client.external_sensor_execution(
+                sensor_execution_args=args,
+            )
+            return DagsterCloudApiGrpcResponse(
+                serialized_response_or_error=serialized_sensor_data_or_error
+            )
         elif api_name == DagsterCloudApi.GET_EXTERNAL_NOTEBOOK_DATA:
             client = self._get_grpc_client(
                 user_code_launcher, deployment_name, cast("str", location_name)
@@ -1066,42 +1029,32 @@ class DagsterCloudAgent:
                     ),
                 )
 
-                run_attributes = extract_run_attributes(deployment_name, run)
-                with observe_execution(
-                    opentelemetry=self._instance.opentelemetry,
-                    event_key=f"{DAGSTER_CLOUD_AGENT_METRIC_PREFIX}.run.launches",
-                    short_description="run execution requests",
-                    attributes=run_attributes,
-                ) as observer:
-                    launcher = scoped_instance.get_run_launcher_for_run(run)  # type: ignore  # (instance subclass)
+                launcher = scoped_instance.get_run_launcher_for_run(run)  # type: ignore  # (instance subclass)
 
-                    if is_isolated_run(run):
-                        launcher.launch_run(LaunchRunContext(dagster_run=run, workspace=None))
-                    else:
-                        scoped_instance.report_engine_event(
-                            f"Launching {run.run_id} without an isolated run environment.",
-                            run,
-                            cls=self.__class__,
-                        )
+                if is_isolated_run(run):
+                    launcher.launch_run(LaunchRunContext(dagster_run=run, workspace=None))
+                else:
+                    scoped_instance.report_engine_event(
+                        f"Launching {run.run_id} without an isolated run environment.",
+                        run,
+                        cls=self.__class__,
+                    )
 
-                        run_location_name = cast(
-                            "str",
-                            run.remote_job_origin.repository_origin.code_location_origin.location_name,
-                        )
+                    run_location_name = cast(
+                        "str",
+                        run.remote_job_origin.repository_origin.code_location_origin.location_name,
+                    )
 
-                        server = user_code_launcher.get_grpc_server(
-                            deployment_name, run_location_name
-                        )
+                    server = user_code_launcher.get_grpc_server(deployment_name, run_location_name)
 
-                        # Record the server handle that we launched it on to for run monitoring
-                        scoped_instance.add_run_tags(
-                            run.run_id, new_tags={SERVER_HANDLE_TAG: str(server.server_handle)}
-                        )
+                    # Record the server handle that we launched it on to for run monitoring
+                    scoped_instance.add_run_tags(
+                        run.run_id, new_tags={SERVER_HANDLE_TAG: str(server.server_handle)}
+                    )
 
-                        launcher.launch_run_from_grpc_client(
-                            scoped_instance, run, server.server_endpoint.create_client()
-                        )
-                    observer.evaluate_result(run=run)
+                    launcher.launch_run_from_grpc_client(
+                        scoped_instance, run, server.server_endpoint.create_client()
+                    )
 
                 return DagsterCloudApiSuccess()
         elif api_name == DagsterCloudApi.TERMINATE_RUN:

dagster_cloud/instance/__init__.py

@@ -1,7 +1,7 @@
 import copy
 import socket
 import uuid
-from collections.abc import Mapping, Sequence
+from collections.abc import Sequence
 from contextlib import ExitStack
 from functools import lru_cache
 from typing import TYPE_CHECKING, Any, Optional, Union
@@ -34,11 +34,8 @@ from urllib3 import Retry
 
 from dagster_cloud.agent import AgentQueuesConfig
 from dagster_cloud.auth.constants import decode_agent_token
-from dagster_cloud.opentelemetry.config import opentelemetry_config_schema
-from dagster_cloud.opentelemetry.controller import OpenTelemetryController
 from dagster_cloud.storage.client import dagster_cloud_api_config
 from dagster_cloud.util import get_env_names_from_config, is_isolated_run
-from dagster_cloud.version import __version__
 
 if TYPE_CHECKING:
     from requests import Session
@@ -83,7 +80,6 @@ class DagsterCloudAgentInstance(DagsterCloudInstance):
         allowed_full_deployment_locations=None,
         allowed_branch_deployment_locations=None,
         agent_metrics=None,
-        opentelemetry=None,
         **kwargs,
     ):
         super().__init__(*args, **kwargs)
@@ -155,12 +151,6 @@ class DagsterCloudAgentInstance(DagsterCloudInstance):
             allowed_branch_deployment_locations
         )
 
-        self._opentelemetry_config: Optional[Mapping[str, Any]] = self._get_processed_config(
-            "opentelemetry", opentelemetry, opentelemetry_config_schema()
-        )
-
-        self._opentelemetry_controller: Optional[OpenTelemetryController] = None
-
         self._instance_uuid = str(uuid.uuid4())
 
     @property
@@ -582,9 +572,6 @@ instance_class:
                 is_required=False,
                 description="List of allowed location names for branch deployments",
             ),
-            "opentelemetry": Field(
-                opentelemetry_config_schema(), is_required=False, default_value={"enabled": False}
-            ),
         }
 
     @classmethod
@@ -667,9 +654,6 @@ instance_class:
 
     def dispose(self) -> None:
         super().dispose()
-        if self._opentelemetry_controller:
-            self._opentelemetry_controller.dispose()
-            self._opentelemetry_controller = None
         self._exit_stack.close()
 
     @property
@@ -690,17 +674,6 @@ instance_class:
         # potentially overridden interval in the serverless user code launcher
         return 30
 
-    @property
-    def opentelemetry(self) -> OpenTelemetryController:
-        if not self._opentelemetry_controller:
-            self._opentelemetry_controller = OpenTelemetryController(
-                instance_id=self.instance_uuid,
-                version=__version__,
-                config=self._opentelemetry_config,
-            )
-
-        return self._opentelemetry_controller
-
 
 @lru_cache(maxsize=100)  # Scales on order of active branch deployments
 def _cached_inject_deployment(

dagster_cloud/pex/grpc/server/manager.py

@@ -16,7 +16,7 @@ from dagster._utils.error import SerializableErrorInfo, serializable_error_info_
 from dagster_cloud_cli.core.workspace import CodeLocationDeployData, PexMetadata
 from dagster_shared import seven
 from dagster_shared.ipc import open_ipc_subprocess
-from pydantic import BaseModel, Extra
+from pydantic import BaseModel
 
 from dagster_cloud.pex.grpc.server.registry import PexS3Registry
 from dagster_cloud.pex.grpc.types import PexServerHandle
@@ -25,7 +25,7 @@ from dagster_cloud.workspace.user_code_launcher.utils import get_grpc_server_env
 logger = logging.getLogger("dagster.multipex")
 
 
-class PexProcessEntry(BaseModel, frozen=True, extra=Extra.forbid, arbitrary_types_allowed=True):
+class PexProcessEntry(BaseModel, frozen=True, extra="forbid", arbitrary_types_allowed=True):
     pex_server_handle: PexServerHandle
     grpc_server_process: subprocess.Popen
     grpc_client: DagsterGrpcClient
@@ -33,7 +33,7 @@ class PexProcessEntry(BaseModel, frozen=True, extra=Extra.forbid, arbitrary_type
     heartbeat_thread: threading.Thread
 
 
-class PexErrorEntry(BaseModel, frozen=True, extra=Extra.forbid, arbitrary_types_allowed=True):
+class PexErrorEntry(BaseModel, frozen=True, extra="forbid", arbitrary_types_allowed=True):
     pex_server_handle: PexServerHandle
     error: SerializableErrorInfo
 

dagster_cloud/storage/event_logs/storage.py

@@ -17,6 +17,7 @@ from dagster._core.event_api import (
     EventLogRecord,
     EventRecordsFilter,
     EventRecordsResult,
+    PartitionKeyFilter,
     RunShardedEventsCursor,
     RunStatusChangeRecordsFilter,
 )
@@ -27,6 +28,7 @@ from dagster._core.instance.config import PoolConfig, PoolGranularity
 from dagster._core.storage.asset_check_execution_record import (
     AssetCheckExecutionRecord,
     AssetCheckExecutionRecordStatus,
+    AssetCheckPartitionInfo,
 )
 from dagster._core.storage.dagster_run import DagsterRunStatsSnapshot
 from dagster._core.storage.event_log.base import (
@@ -378,6 +380,7 @@ def _asset_check_execution_record_from_graphql(data: dict, key: AssetCheckKey):
         status=AssetCheckExecutionRecordStatus(data["status"]),
         event=_event_log_entry_from_graphql(data["event"]),
         create_timestamp=data["createTimestamp"],
+        partition=data.get("partition"),
     )
 
 
@@ -1232,14 +1235,25 @@ class GraphQLEventLogStorage(EventLogStorage, ConfigurableClass):
         limit: int,
         cursor: Optional[int] = None,
         status: Optional[AbstractSet[AssetCheckExecutionRecordStatus]] = None,
+        partition_filter: Optional[PartitionKeyFilter] = None,
     ) -> Sequence[AssetCheckExecutionRecord]:
         raise NotImplementedError("Not callable from user cloud")
 
     def get_latest_asset_check_execution_by_key(
-        self, check_keys: Sequence[AssetCheckKey]
+        self,
+        check_keys: Sequence[AssetCheckKey],
+        partition_filter: Optional[PartitionKeyFilter] = None,
     ) -> Mapping[AssetCheckKey, AssetCheckExecutionRecord]:
         raise NotImplementedError("Not callable from user cloud")
 
+    def get_asset_check_partition_info(
+        self,
+        keys: Sequence[AssetCheckKey],
+        after_storage_id: Optional[int] = None,
+        partition_keys: Optional[Sequence[str]] = None,
+    ) -> Sequence[AssetCheckPartitionInfo]:
+        raise NotImplementedError("Not callable from user cloud")
+
     def fetch_materializations(
         self,
         records_filter: Union[AssetKey, AssetRecordsFilter],

dagster_cloud/version.py

@@ -1 +1 @@
-__version__ = "1.12.11"
+__version__ = "1.12.13"

dagster_cloud/workspace/user_code_launcher/user_code_launcher.py

@@ -56,7 +56,6 @@ from dagster_cloud_cli.core.errors import raise_http_error
 from dagster_cloud_cli.core.workspace import CodeLocationDeployData
 from typing_extensions import Self, TypeAlias
 
-from dagster_cloud.agent.instrumentation.constants import DAGSTER_CLOUD_AGENT_METRIC_PREFIX
 from dagster_cloud.agent.queries import GET_AGENTS_QUERY
 from dagster_cloud.api.dagster_cloud_api import (
     CheckSnapshotResult,
@@ -85,8 +84,6 @@ from dagster_cloud.execution.monitoring import (
     start_run_worker_monitoring_thread,
 )
 from dagster_cloud.instance import DagsterCloudAgentInstance
-from dagster_cloud.opentelemetry.controller import OpenTelemetryController
-from dagster_cloud.opentelemetry.observers.execution_observer import observe_execution
 from dagster_cloud.pex.grpc.client import MultiPexGrpcClient
 from dagster_cloud.pex.grpc.types import (
     CreatePexServerArgs,
@@ -1125,11 +1122,6 @@ class DagsterCloudUserCodeLauncher(
     ):
         deployment_name, location_name = to_update_key
 
-        attributes = {
-            "deployment": deployment_name,
-            "location": location_name,
-        }
-
         code_location_deploy_data = desired_entry.code_location_deploy_data
         pex_metadata = code_location_deploy_data.pex_metadata
         deployment_info = (
@@ -1142,19 +1134,13 @@ class DagsterCloudUserCodeLauncher(
                 self._logger.info(
                     f"Waiting for new grpc server for {deployment_name}:{location_name} for {deployment_info} to be ready..."
                 )
-                with observe_execution(
-                    opentelemetry=self.opentelemetry,
-                    event_key=f"{DAGSTER_CLOUD_AGENT_METRIC_PREFIX}.user_code.server.process_wait",
-                    short_description="waiting for new server process to be ready",
-                    attributes=attributes,
-                ):
-                    await self._wait_for_new_server_ready(
-                        deployment_name,
-                        location_name,
-                        desired_entry,
-                        server_or_error.server_handle,
-                        server_or_error.server_endpoint,
-                    )
+                await self._wait_for_new_server_ready(
+                    deployment_name,
+                    location_name,
+                    desired_entry,
+                    server_or_error.server_handle,
+                    server_or_error.server_endpoint,
+                )
             except Exception:
                 error_info = serializable_error_info_from_exc_info(sys.exc_info())
                 self._logger.error(
@@ -1164,18 +1150,12 @@ class DagsterCloudUserCodeLauncher(
                 server_or_error = error_info
 
         if should_upload:
-            with observe_execution(
-                opentelemetry=self.opentelemetry,
-                event_key=f"{DAGSTER_CLOUD_AGENT_METRIC_PREFIX}.user_code.upload",
-                short_description="uploading user code data",
-                attributes=attributes,
-            ):
-                await self._try_update_location_data(
-                    deployment_name,
-                    location_name,
-                    server_or_error,
-                    desired_entry.code_location_deploy_data,
-                )
+            await self._try_update_location_data(
+                deployment_name,
+                location_name,
+                server_or_error,
+                desired_entry.code_location_deploy_data,
+            )
 
         # Once we've verified that the new server has uploaded its data successfully, swap in
         # the server to start serving new requests
@@ -1836,28 +1816,16 @@ class DagsterCloudUserCodeLauncher(
                         # confirm it's a valid image since _start_new_server_spinup will launch a container
                         self._check_for_image(desired_entry.code_location_deploy_data)
 
-                        attributes = {
-                            "deployment": deployment_name,
-                            "location": location_name,
-                            "image": desired_entry.code_location_deploy_data.image,
-                            "python_version": desired_python_version,
-                        }
-                        with observe_execution(
-                            opentelemetry=self.opentelemetry,
-                            event_key=f"{DAGSTER_CLOUD_AGENT_METRIC_PREFIX}.user_code.multipex_server.start",
-                            short_description="starting new multipex server",
-                            attributes=attributes,
-                        ):
-                            multipex_server = self._start_new_server_spinup(
-                                deployment_name, location_name, desired_entry
-                            )
-                            self._multipex_servers[to_update_key] = multipex_server
-                            assert self._get_multipex_server(
-                                deployment_name,
-                                location_name,
-                                desired_entry.code_location_deploy_data,
-                            )
-                            new_multipex_servers[to_update_key] = multipex_server
+                        multipex_server = self._start_new_server_spinup(
+                            deployment_name, location_name, desired_entry
+                        )
+                        self._multipex_servers[to_update_key] = multipex_server
+                        assert self._get_multipex_server(
+                            deployment_name,
+                            location_name,
+                            desired_entry.code_location_deploy_data,
+                        )
+                        new_multipex_servers[to_update_key] = multipex_server
                     else:
                         self._logger.info(
                             f"Found running multipex server for {multipex_server_repr}"
@@ -2173,11 +2141,6 @@ class DagsterCloudUserCodeLauncher(
     def _start_new_dagster_server(
         self, deployment_name: str, location_name: str, desired_entry: UserCodeLauncherEntry
     ) -> DagsterCloudGrpcServer:
-        attributes = {
-            "deployment": deployment_name,
-            "location": location_name,
-        }
-
         if desired_entry.code_location_deploy_data.pex_metadata:
             multipex_server = self._get_multipex_server(
                 deployment_name, location_name, desired_entry.code_location_deploy_data
@@ -2185,45 +2148,26 @@ class DagsterCloudUserCodeLauncher(
 
             assert multipex_server  # should have been started earlier or we should never reach here
 
-            if desired_entry.code_location_deploy_data.pex_metadata.python_version:
-                attributes["python_version"] = (
-                    desired_entry.code_location_deploy_data.pex_metadata.python_version
-                )
+            self._create_pex_server(deployment_name, location_name, desired_entry, multipex_server)
 
-            with observe_execution(
-                opentelemetry=self.opentelemetry,
-                event_key=f"{DAGSTER_CLOUD_AGENT_METRIC_PREFIX}.user_code.pex_server.start",
-                short_description="starting new pex server",
-                attributes=attributes,
-            ):
-                self._create_pex_server(
-                    deployment_name, location_name, desired_entry, multipex_server
-                )
+            server_handle = multipex_server.server_handle
+            multipex_endpoint = multipex_server.server_endpoint
 
-                server_handle = multipex_server.server_handle
-                multipex_endpoint = multipex_server.server_endpoint
-
-                # start a new pex server on the multipexer, which we can count on already existing
-                return DagsterCloudGrpcServer(
-                    server_handle,
-                    multipex_endpoint.with_metadata(
-                        [
-                            ("has_pex", "1"),
-                            ("deployment", deployment_name),
-                            ("location", location_name),
-                            ("timestamp", str(int(desired_entry.update_timestamp))),
-                        ],
-                    ),
-                    desired_entry.code_location_deploy_data,
-                )
+            # start a new pex server on the multipexer, which we can count on already existing
+            return DagsterCloudGrpcServer(
+                server_handle,
+                multipex_endpoint.with_metadata(
+                    [
+                        ("has_pex", "1"),
+                        ("deployment", deployment_name),
+                        ("location", location_name),
+                        ("timestamp", str(int(desired_entry.update_timestamp))),
+                    ],
+                ),
+                desired_entry.code_location_deploy_data,
+            )
         else:
-            with observe_execution(
-                opentelemetry=self.opentelemetry,
-                event_key=f"{DAGSTER_CLOUD_AGENT_METRIC_PREFIX}.user_code.code_server.start",
-                short_description="new code server spin up",
-                attributes=attributes,
-            ):
-                return self._start_new_server_spinup(deployment_name, location_name, desired_entry)
+            return self._start_new_server_spinup(deployment_name, location_name, desired_entry)
 
     def get_grpc_endpoint(
         self,
@@ -2443,13 +2387,6 @@ class DagsterCloudUserCodeLauncher(
                 )
                 return response
 
-    @property
-    def opentelemetry(self) -> Optional[OpenTelemetryController]:
-        if not self.has_instance:
-            return None
-        else:
-            return self._instance.opentelemetry
-
     def upload_job_snap_direct(
         self,
         deployment_name: str,

{dagster_cloud-1.12.11.dist-info → dagster_cloud-1.12.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dagster-cloud
-Version: 1.12.11
+Version: 1.12.13
 Author-email: Elementl <support@elementl.com>
 License: Apache-2.0
 Project-URL: Homepage, https://dagster.io/cloud
@@ -30,13 +30,9 @@ Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Operating System :: OS Independent
 Requires-Python: <3.15,>=3.9
 Description-Content-Type: text/markdown
-Requires-Dist: dagster==1.12.11
-Requires-Dist: dagster-shared==1.12.11
-Requires-Dist: dagster-cloud-cli==1.12.11
-Requires-Dist: opentelemetry-api<2,>=1.27.0
-Requires-Dist: opentelemetry-sdk<2,>=1.27.0
-Requires-Dist: opentelemetry-exporter-otlp-proto-grpc<2,>=1.27.0
-Requires-Dist: opentelemetry-exporter-otlp-proto-http<2,>=1.27.0
+Requires-Dist: dagster==1.12.13
+Requires-Dist: dagster-shared==1.12.13
+Requires-Dist: dagster-cloud-cli==1.12.13
 Requires-Dist: pex<2.60.0,>=2.1.132
 Requires-Dist: questionary
 Requires-Dist: requests
@@ -55,24 +51,29 @@ Requires-Dist: pylint; extra == "tests"
 Requires-Dist: pytest; extra == "tests"
 Requires-Dist: types-PyYAML; extra == "tests"
 Requires-Dist: types-requests; extra == "tests"
-Requires-Dist: dagster-cloud-test-infra; extra == "tests"
 Requires-Dist: dbt-bigquery>=1.9.0; extra == "tests"
 Requires-Dist: dbt-core; extra == "tests"
 Requires-Dist: dbt-snowflake; extra == "tests"
 Requires-Dist: dbt-duckdb; extra == "tests"
 Requires-Dist: dagster-dbt; extra == "tests"
 Requires-Dist: dagster-k8s; extra == "tests"
+Requires-Dist: dagster-docker; extra == "tests"
 Requires-Dist: dagster-cloud-backend; extra == "tests"
+Requires-Dist: dagster-test; extra == "tests"
+Requires-Dist: dagster-cloud-test-infra; extra == "tests"
+Requires-Dist: dagster-cloud-dagit; extra == "tests"
+Requires-Dist: dagster-dg-cli; extra == "tests"
+Requires-Dist: syrupy; extra == "tests"
 Provides-Extra: insights
 Requires-Dist: pyarrow; extra == "insights"
 Provides-Extra: docker
 Requires-Dist: docker; extra == "docker"
-Requires-Dist: dagster-docker==0.28.11; extra == "docker"
+Requires-Dist: dagster-docker==0.28.13; extra == "docker"
 Provides-Extra: kubernetes
 Requires-Dist: kubernetes; extra == "kubernetes"
-Requires-Dist: dagster-k8s==0.28.11; extra == "kubernetes"
+Requires-Dist: dagster-k8s==0.28.13; extra == "kubernetes"
 Provides-Extra: ecs
-Requires-Dist: dagster-aws==0.28.11; extra == "ecs"
+Requires-Dist: dagster-aws==0.28.13; extra == "ecs"
 Requires-Dist: boto3; extra == "ecs"
 Provides-Extra: sandbox
 Requires-Dist: supervisor; extra == "sandbox"