dagster-cloud 1.10.11__py3-none-any.whl → 1.12.6__py3-none-any.whl

dagster_cloud/workspace/ecs/client.py

@@ -64,6 +64,7 @@ class Client:
         grace_period: int = DEFAULT_ECS_GRACE_PERIOD,
         launch_type: str = "FARGATE",
         show_debug_cluster_info: bool = True,
+        assign_public_ip: Optional[bool] = None,
     ):
         self.ecs = ecs_client if ecs_client else boto3.client("ecs", config=config)
         self.logs = boto3.client("logs", config=config)
@@ -85,6 +86,7 @@ class Client:
         self.grace_period = check.int_param(grace_period, "grace_period")
         self.launch_type = check.str_param(launch_type, "launch_type")
         self._namespace: Optional[str] = None
+        self._assign_public_ip_override = assign_public_ip
 
     @property
     def ec2(self):
@@ -110,19 +112,22 @@ class Client:
             name="serviceLongArnFormat",
             effectiveSettings=True,
         )
-        return settings["settings"][0]["value"] == "enabled"  # pyright: ignore[reportTypedDictNotRequiredAccess]
+        return settings["settings"][0]["value"] == "enabled"
 
     @property
     @cached_method
     def network_configuration(self):
+        if self.launch_type != "FARGATE":
+            assign_public_ip = None
+        elif self._assign_public_ip_override is not None:
+            assign_public_ip = "ENABLED" if self._assign_public_ip_override else "DISABLED"
+        else:
+            assign_public_ip = self._infer_assign_public_ip()
+
         network_configuration = {
             "awsvpcConfiguration": {
                 "subnets": self.subnet_ids,
-                **(
-                    {"assignPublicIp": self._assign_public_ip()}
-                    if self.launch_type == "FARGATE"
-                    else {}
-                ),
+                **({"assignPublicIp": assign_public_ip} if assign_public_ip else {}),
             },
         }
 
@@ -155,7 +160,7 @@ class Client:
         ):
             task_definition_arn = (
                 self.ecs.register_task_definition(
-                    **desired_task_definition_config.task_definition_dict()  # pyright: ignore[reportArgumentType]
+                    **desired_task_definition_config.task_definition_dict()
                 )
                 .get("taskDefinition")
                 .get("taskDefinitionArn")
@@ -461,10 +466,10 @@ class Client:
 
         task_arn = (
             self.ecs.run_task(
-                taskDefinition=task_definition_arn,  # pyright: ignore[reportArgumentType]
+                taskDefinition=task_definition_arn,
                 cluster=self.cluster_name,
-                launchType=self.launch_type,  # pyright: ignore[reportArgumentType]
-                networkConfiguration=self.network_configuration,  # pyright: ignore[reportArgumentType]
+                launchType=self.launch_type,
+                networkConfiguration=self.network_configuration,
             )
             .get("tasks", [{}])[0]
             .get("taskArn")
@@ -472,14 +477,14 @@ class Client:
 
         self.ecs.get_waiter("tasks_stopped").wait(
             cluster=self.cluster_name,
-            tasks=[task_arn],  # pyright: ignore[reportArgumentType]
+            tasks=[task_arn],
             WaiterConfig={"Delay": 1, "MaxAttempts": self.timeout},
         )
 
         exit_code = (
             self.ecs.describe_tasks(
                 cluster=self.cluster_name,
-                tasks=[task_arn],  # pyright: ignore[reportArgumentType]
+                tasks=[task_arn],
             )
             .get("tasks", [{}])[0]
             .get("containers", [{}])[0]
@@ -541,7 +546,7 @@ class Client:
                 for key, value in tags.items()
             ]
 
-        arn = self.ecs.create_service(**params).get("service").get("serviceArn")  # pyright: ignore[reportArgumentType]
+        arn = self.ecs.create_service(**params).get("service").get("serviceArn")
 
         return Service(client=self, arn=arn)
 
@@ -716,7 +721,7 @@ class Client:
 
             stopped_tasks = sorted(
                 stopped_tasks,
-                key=lambda task: task["createdAt"].timestamp(),  # pyright: ignore[reportTypedDictNotRequiredAccess]
+                key=lambda task: task["createdAt"].timestamp(),
                 reverse=True,
             )
             return stopped_tasks
@@ -760,7 +765,7 @@ class Client:
                 if service["Name"] == service_name:
                     return service["Id"]
 
-    def _assign_public_ip(self):
+    def _infer_assign_public_ip(self):
         # https://docs.aws.amazon.com/AmazonECS/latest/userguide/fargate-task-networking.html
         # Assign a public IP if any of the subnets are public
         route_tables = self.ec2.route_tables.filter(
@@ -780,14 +785,14 @@ class Client:
         task = self.ecs.describe_tasks(cluster=self.cluster_name, tasks=[task_arn]).get("tasks")[0]
 
         task_definition_arn = task.get("taskDefinitionArn")
-        task_definition = self.ecs.describe_task_definition(taskDefinition=task_definition_arn).get(  # pyright: ignore[reportArgumentType]
+        task_definition = self.ecs.describe_task_definition(taskDefinition=task_definition_arn).get(
             "taskDefinition"
         )
 
         matching_container_definitions = [
             container_definition
             for container_definition in task_definition.get("containerDefinitions", [])
-            if container_definition["name"] == container_name  # pyright: ignore[reportTypedDictNotRequiredAccess]
+            if container_definition["name"] == container_name
         ]
         if not matching_container_definitions:
             raise Exception(f"Could not find container with name {container_name}")
@@ -795,7 +800,7 @@ class Client:
         container_definition = matching_container_definitions[0]
 
         log_stream_prefix = (
-            container_definition.get("logConfiguration").get("options").get("awslogs-stream-prefix")  # pyright: ignore[reportOptionalMemberAccess]
+            container_definition.get("logConfiguration").get("options").get("awslogs-stream-prefix")
         )
         container_name = container_definition.get("name")
         task_id = task_arn.split("/")[-1]

dagster_cloud/workspace/ecs/launcher.py

@@ -31,9 +31,15 @@ from dagster_cloud.workspace.ecs.client import (
     DEFAULT_ECS_TIMEOUT,
     ECS_EXEC_LINUX_PARAMETERS,
     Client,
+    get_debug_ecs_prompt,
 )
+from dagster_cloud.workspace.ecs.run_launcher import CloudEcsRunLauncher
 from dagster_cloud.workspace.ecs.service import Service
-from dagster_cloud.workspace.ecs.utils import get_ecs_human_readable_label, unique_ecs_resource_name
+from dagster_cloud.workspace.ecs.utils import (
+    get_ecs_human_readable_label,
+    get_server_task_definition_family,
+    unique_ecs_resource_name,
+)
 from dagster_cloud.workspace.user_code_launcher import (
     DEFAULT_SERVER_PROCESS_STARTUP_TIMEOUT,
     SHARED_USER_CODE_LAUNCHER_CONFIG,
@@ -50,10 +56,6 @@ from dagster_cloud.workspace.user_code_launcher.utils import (
     get_grpc_server_env,
 )
 
-from .client import get_debug_ecs_prompt
-from .run_launcher import CloudEcsRunLauncher
-from .utils import get_server_task_definition_family
-
 EcsServerHandleType = Service
 
 CONTAINER_NAME = "dagster"
@@ -90,6 +92,7 @@ class EcsUserCodeLauncher(DagsterCloudUserCodeLauncher[EcsServerHandleType], Con
         enable_ecs_exec=False,
         server_task_definition_prefix: str = "server",
         run_task_definition_prefix: str = "run",
+        assign_public_ip: Optional[bool] = None,
         **kwargs,
     ):
         self.ecs = boto3.client("ecs")
@@ -182,6 +185,7 @@ class EcsUserCodeLauncher(DagsterCloudUserCodeLauncher[EcsServerHandleType], Con
             timeout=self._ecs_timeout,
             grace_period=self._ecs_grace_period,
             launch_type=self.launch_type,
+            assign_public_ip=assign_public_ip,
         )
         super().__init__(**kwargs)
 
@@ -297,6 +301,16 @@ class EcsUserCodeLauncher(DagsterCloudUserCodeLauncher[EcsServerHandleType], Con
                 "run_task_definition_prefix": Field(
                     str, is_required=False, default_value="dagsterrun"
                 ),
+                "assign_public_ip": Field(
+                    Noneable(bool),
+                    is_required=False,
+                    default_value=None,
+                    description=(
+                        "When using the FARGATE launch type, the launcher will attempt to automatically determine if it is "
+                        "necessary to assign a public IP to the ECS task. In complex network topologies, this automatic "
+                        "determination may not be accurate. In this case, you can explicitly set this value to True or False."
+                    ),
+                ),
             },
             SHARED_ECS_CONFIG,
             SHARED_USER_CODE_LAUNCHER_CONFIG,

dagster_cloud/workspace/ecs/run_launcher.py

@@ -2,8 +2,7 @@ import dagster._check as check
 from dagster_aws.ecs import EcsRunLauncher
 
 from dagster_cloud.instance import DagsterCloudAgentInstance
-
-from .utils import get_run_task_definition_family
+from dagster_cloud.workspace.ecs.utils import get_run_task_definition_family
 
 
 class CloudEcsRunLauncher(EcsRunLauncher[DagsterCloudAgentInstance]):

dagster_cloud/workspace/ecs/utils.py

@@ -2,10 +2,13 @@ import hashlib
 import re
 from typing import Optional
 
-from dagster._core.remote_representation.origin import RemoteJobOrigin
+from dagster._core.remote_origin import RemoteJobOrigin
 from dagster_aws.ecs.utils import sanitize_family
 
-from ..user_code_launcher.utils import get_human_readable_label, unique_resource_name
+from dagster_cloud.workspace.user_code_launcher.utils import (
+    get_human_readable_label,
+    unique_resource_name,
+)
 
 
 def unique_ecs_resource_name(deployment_name, location_name):

dagster_cloud/workspace/kubernetes/__init__.py

@@ -1 +1 @@
-from .launcher import K8sUserCodeLauncher as K8sUserCodeLauncher
+from dagster_cloud.workspace.kubernetes.launcher import K8sUserCodeLauncher as K8sUserCodeLauncher

dagster_cloud/workspace/kubernetes/launcher.py

@@ -33,17 +33,7 @@ from dagster_cloud.api.dagster_cloud_api import UserCodeDeploymentType
 from dagster_cloud.constants import RESERVED_ENV_VAR_NAMES
 from dagster_cloud.execution.cloud_run_launcher.k8s import CloudK8sRunLauncher
 from dagster_cloud.execution.monitoring import CloudContainerResourceLimits
-
-from ..user_code_launcher import (
-    DEFAULT_SERVER_PROCESS_STARTUP_TIMEOUT,
-    SHARED_USER_CODE_LAUNCHER_CONFIG,
-    DagsterCloudGrpcServer,
-    DagsterCloudUserCodeLauncher,
-    ServerEndpoint,
-    UserCodeLauncherEntry,
-)
-from ..user_code_launcher.utils import deterministic_label_for_location
-from .utils import (
+from dagster_cloud.workspace.kubernetes.utils import (
     SERVICE_PORT,
     construct_code_location_deployment,
     construct_code_location_service,
@@ -51,11 +41,20 @@ from .utils import (
     unique_k8s_resource_name,
     wait_for_deployment_complete,
 )
+from dagster_cloud.workspace.user_code_launcher import (
+    DEFAULT_SERVER_PROCESS_STARTUP_TIMEOUT,
+    SHARED_USER_CODE_LAUNCHER_CONFIG,
+    DagsterCloudGrpcServer,
+    DagsterCloudUserCodeLauncher,
+    ServerEndpoint,
+    UserCodeLauncherEntry,
+)
+from dagster_cloud.workspace.user_code_launcher.utils import deterministic_label_for_location
 
 DEFAULT_DEPLOYMENT_STARTUP_TIMEOUT = 300
 DEFAULT_IMAGE_PULL_GRACE_PERIOD = 30
 
-from ..config_schema.kubernetes import SHARED_K8S_CONFIG
+from dagster_cloud.workspace.config_schema.kubernetes import SHARED_K8S_CONFIG
 
 
 class K8sHandle(NamedTuple):

dagster_cloud/workspace/kubernetes/utils.py

@@ -11,8 +11,7 @@ from dagster_k8s.models import k8s_model_from_dict
 from kubernetes import client
 
 from dagster_cloud.instance import DagsterCloudAgentInstance
-
-from ..user_code_launcher.utils import (
+from dagster_cloud.workspace.user_code_launcher.utils import (
     deterministic_label_for_location,
     get_grpc_server_env,
     get_human_readable_label,

dagster_cloud/workspace/user_code_launcher/__init__.py

@@ -1,5 +1,7 @@
-from .process import ProcessUserCodeLauncher as ProcessUserCodeLauncher
-from .user_code_launcher import (
+from dagster_cloud.workspace.user_code_launcher.process import (
+    ProcessUserCodeLauncher as ProcessUserCodeLauncher,
+)
+from dagster_cloud.workspace.user_code_launcher.user_code_launcher import (
     DEFAULT_SERVER_PROCESS_STARTUP_TIMEOUT as DEFAULT_SERVER_PROCESS_STARTUP_TIMEOUT,
     DEFAULT_SERVER_TTL_SECONDS as DEFAULT_SERVER_TTL_SECONDS,
     SHARED_USER_CODE_LAUNCHER_CONFIG as SHARED_USER_CODE_LAUNCHER_CONFIG,
@@ -8,7 +10,7 @@ from .user_code_launcher import (
     ServerEndpoint as ServerEndpoint,
     UserCodeLauncherEntry as UserCodeLauncherEntry,
 )
-from .utils import (
+from dagster_cloud.workspace.user_code_launcher.utils import (
     deterministic_label_for_location as deterministic_label_for_location,
     get_human_readable_label as get_human_readable_label,
     unique_resource_name as unique_resource_name,

dagster_cloud/workspace/user_code_launcher/process.py

@@ -26,9 +26,7 @@ from dagster_cloud.api.dagster_cloud_api import UserCodeDeploymentType
 from dagster_cloud.execution.cloud_run_launcher.process import CloudProcessRunLauncher
 from dagster_cloud.execution.monitoring import CloudContainerResourceLimits
 from dagster_cloud.pex.grpc import MultiPexGrpcClient
-from dagster_cloud.workspace.user_code_launcher.utils import get_grpc_server_env
-
-from .user_code_launcher import (
+from dagster_cloud.workspace.user_code_launcher.user_code_launcher import (
     DEFAULT_SERVER_PROCESS_STARTUP_TIMEOUT,
     SHARED_USER_CODE_LAUNCHER_CONFIG,
     DagsterCloudGrpcServer,
@@ -36,6 +34,7 @@ from .user_code_launcher import (
     ServerEndpoint,
     UserCodeLauncherEntry,
 )
+from dagster_cloud.workspace.user_code_launcher.utils import get_grpc_server_env
 
 CLEANUP_ZOMBIE_PROCESSES_INTERVAL = 5
 

dagster_cloud/workspace/user_code_launcher/user_code_launcher.py

@@ -27,13 +27,13 @@ from dagster._core.definitions.selector import JobSelector
 from dagster._core.errors import DagsterUserCodeUnreachableError
 from dagster._core.instance import MayHaveInstanceWeakref
 from dagster._core.launcher import RunLauncher
-from dagster._core.remote_representation import RemoteRepositoryOrigin
-from dagster._core.remote_representation.external_data import (
-    extract_serialized_job_snap_from_serialized_job_data_snap,
-)
-from dagster._core.remote_representation.origin import (
+from dagster._core.remote_origin import (
     CodeLocationOrigin,
     RegisteredCodeLocationOrigin,
+    RemoteRepositoryOrigin,
+)
+from dagster._core.remote_representation.external_data import (
+    extract_serialized_job_snap_from_serialized_job_data_snap,
 )
 from dagster._grpc.client import DagsterGrpcClient
 from dagster._grpc.types import GetCurrentImageResult, ListRepositoriesResponse
@@ -45,7 +45,11 @@ from dagster._serdes import (
     whitelist_for_serdes,
 )
 from dagster._time import get_current_timestamp
-from dagster._utils.error import SerializableErrorInfo, serializable_error_info_from_exc_info
+from dagster._utils.error import (
+    SerializableErrorInfo,
+    serializable_error_info_from_exc_info,
+    truncate_serialized_error,
+)
 from dagster._utils.merger import merge_dicts
 from dagster._utils.typed_dict import init_optional_typeddict
 from dagster_cloud_cli.core.errors import raise_http_error
@@ -91,7 +95,6 @@ from dagster_cloud.pex.grpc.types import (
     ShutdownPexServerArgs,
 )
 from dagster_cloud.util import diff_serializable_namedtuple_map
-from dagster_cloud.util.errors import truncate_serialized_error
 
 DEFAULT_SERVER_PROCESS_STARTUP_TIMEOUT = 180
 DEFAULT_MAX_TTL_SERVERS = 25
@@ -398,6 +401,7 @@ class DagsterCloudUserCodeLauncher(
         self._run_worker_statuses_dict: dict[str, list[CloudRunWorkerStatus]] = {}
         self._run_worker_monitoring_lock = threading.Lock()
 
+        self._in_progress_reconcile_start_time = time.time()
         self._reconcile_count = 0
         self._reconcile_grpc_metadata_shutdown_event = threading.Event()
         self._reconcile_grpc_metadata_thread = None
@@ -641,6 +645,7 @@ class DagsterCloudUserCodeLauncher(
             response = self._instance.requests_managed_retries_session.put(
                 url=upload_data.presigned_put_url,
                 data=file,
+                timeout=self._instance.dagster_cloud_api_timeout,
             )
             raise_http_error(response)
 
@@ -884,23 +889,32 @@ class DagsterCloudUserCodeLauncher(
             repository_name,
             code_pointer,
         ) in list_repositories_response.repository_code_pointer_dict.items():
-            external_repository_chunks = [
-                chunk
-                async for chunk in client.gen_streaming_external_repository(
+            if os.getenv("DAGSTER_CLOUD_USE_STREAMING_EXTERNAL_REPOSITORY"):
+                external_repository_chunks = [
+                    chunk
+                    async for chunk in client.gen_streaming_external_repository(
+                        remote_repository_origin=RemoteRepositoryOrigin(
+                            location_origin,
+                            repository_name,
+                        ),
+                        defer_snapshots=True,
+                    )
+                ]
+
+                serialized_repository_data = "".join(
+                    [
+                        chunk["serialized_external_repository_chunk"]
+                        for chunk in external_repository_chunks
+                    ]
+                )
+            else:
+                serialized_repository_data = await client.gen_external_repository(
                     remote_repository_origin=RemoteRepositoryOrigin(
                         location_origin,
                         repository_name,
                     ),
                     defer_snapshots=True,
                 )
-            ]
-
-            serialized_repository_data = "".join(
-                [
-                    chunk["serialized_external_repository_chunk"]
-                    for chunk in external_repository_chunks
-                ]
-            )
 
             # Don't deserialize in case there are breaking changes - let the server do it
             upload_repo_datas.append(
@@ -1476,6 +1490,8 @@ class DagsterCloudUserCodeLauncher(
                 self._logger.exception("Failed to refresh actual entries.")
             self._last_refreshed_actual_entries = now
 
+        self._in_progress_reconcile_start_time = time.time()
+
         self._reconcile(
             desired_entries,
             upload_locations,
@@ -1492,6 +1508,7 @@ class DagsterCloudUserCodeLauncher(
                 f"Started polling for requests from {self._instance.dagster_cloud_url}"
             )
 
+        self._in_progress_reconcile_start_time = None
         self._reconcile_count += 1
 
     def _update_metrics_thread(self, shutdown_event):
@@ -1516,9 +1533,29 @@ class DagsterCloudUserCodeLauncher(
         # thread-safe since reconcile_count is an integer
         return self._reconcile_count > 0
 
-    def _make_check_on_running_server_endpoint(self, server_endpoint: ServerEndpoint):
-        # Ensure that server_endpoint is bound correctly
-        return lambda: server_endpoint.create_client().ping("")
+    @property
+    def in_progress_reconcile_start_time(self) -> Optional[float]:
+        return self._in_progress_reconcile_start_time
+
+    def _make_check_on_running_server_endpoint(
+        self, server_endpoint: ServerEndpoint
+    ) -> Callable[[], Union[ListRepositoriesResponse, SerializableErrorInfo]]:
+        return lambda: deserialize_value(
+            server_endpoint.create_client().list_repositories(),
+            (ListRepositoriesResponse, SerializableErrorInfo),
+        )
+
+    def _trigger_recovery_server_restart(self, deployment_location: DeploymentAndLocation):
+        del self._actual_entries[deployment_location]
+
+        if deployment_location in self._first_unavailable_times:
+            del self._first_unavailable_times[deployment_location]
+
+        # redeploy the multipex server in this case as well to ensure a fresh start
+        # if it resource contrained (and ensure that we don't try to create the same
+        # PexServerHandle again and delete the code location in a loop)
+        if deployment_location in self._multipex_servers:
+            del self._multipex_servers[deployment_location]
 
     def _refresh_actual_entries(self) -> None:
         for deployment_location, multipex_server in self._multipex_servers.items():
@@ -1549,11 +1586,11 @@ class DagsterCloudUserCodeLauncher(
                     if isinstance(grpc_server_or_error, DagsterCloudGrpcServer):
                         self._logger.warning(
                             "Pex servers disappeared for running code location %s:%s. Removing actual entries to"
-                            " activate reconciliation logic.",
+                            " activate reconciliation logic and deploy a new code server and multipex server.",
                             deployment_name,
                             location_name,
                         )
-                        del self._actual_entries[deployment_location]
+                        self._trigger_recovery_server_restart(deployment_location)
 
         # Check to see if any servers have become unresponsive
         unavailable_server_timeout = int(
@@ -1596,15 +1633,22 @@ class DagsterCloudUserCodeLauncher(
 
                 deployment_name, location_name = deployment_location
                 try:
-                    future.result()
-
+                    response_or_error = future.result()
                     # Successful ping resets the tracked last unavailable time for this code server, if set
                     self._first_unavailable_times.pop(deployment_location, None)
+                    if isinstance(response_or_error, SerializableErrorInfo):
+                        # This can happen if the server was previously healthy but restarted
+                        # and moved into an error state - attempt to recover
+                        self._logger.exception(
+                            f"Code server for {deployment_name}:{location_name} unexpectedly moved into an error state. Deploying a new code server. Observed error: \n{response_or_error.to_string()}"
+                        )
+                        self._trigger_recovery_server_restart(deployment_location)
                 except Exception as e:
                     if (
                         isinstance(e, DagsterUserCodeUnreachableError)
                         and isinstance(e.__cause__, grpc.RpcError)
-                        and cast("grpc.RpcError", e.__cause__).code() == grpc.StatusCode.UNAVAILABLE
+                        and cast("grpc.RpcError", e.__cause__).code()
+                        in {grpc.StatusCode.UNAVAILABLE, grpc.StatusCode.UNKNOWN}
                     ):
                         first_unavailable_time = self._first_unavailable_times.get(
                             deployment_location
@@ -1622,14 +1666,7 @@ class DagsterCloudUserCodeLauncher(
                             self._logger.warning(
                                 f"Code server for {deployment_name}:{location_name} has been unresponsive for more than {unavailable_server_timeout} seconds. Deploying a new code server."
                             )
-                            del self._actual_entries[deployment_location]
-                            del self._first_unavailable_times[deployment_location]
-
-                            # redeploy the multipex server in this case as well to ensure a fresh start
-                            # (and ensure that we don't try to create the same PexServerHandle again and
-                            # delete the code location in a loop)
-                            if deployment_location in self._multipex_servers:
-                                del self._multipex_servers[deployment_location]
+                            self._trigger_recovery_server_restart(deployment_location)
 
                     else:
                         self._logger.exception(

dagster_cloud/workspace/user_code_launcher/utils.py

@@ -125,4 +125,11 @@ def get_grpc_server_env(
             if code_location_deploy_data.executable_path
             else {}
         ),
+        **(
+            {
+                "DAGSTER_CLI_API_GRPC_AUTOLOAD_DEFS_MODULE_NAME": code_location_deploy_data.autoload_defs_module_name
+            }
+            if code_location_deploy_data.autoload_defs_module_name
+            else {}
+        ),
     }

{dagster_cloud-1.10.11.dist-info → dagster_cloud-1.12.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dagster-cloud
-Version: 1.10.11
+Version: 1.12.6
 Author-email: Elementl <support@elementl.com>
 License: Apache-2.0
 Project-URL: Homepage, https://dagster.io/cloud
@@ -26,15 +26,16 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Topic :: System :: Monitoring
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Operating System :: OS Independent
-Requires-Python: <3.13,>=3.9
+Requires-Python: <3.14,>=3.9
 Description-Content-Type: text/markdown
-Requires-Dist: dagster==1.10.11
-Requires-Dist: dagster-cloud-cli==1.10.11
+Requires-Dist: dagster==1.12.6
+Requires-Dist: dagster-shared==1.12.6
+Requires-Dist: dagster-cloud-cli==1.12.6
 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: pex<3,>=2.1.132
+Requires-Dist: pex<2.60.0,>=2.1.132
 Requires-Dist: questionary
 Requires-Dist: requests
 Requires-Dist: typer
@@ -64,12 +65,12 @@ Provides-Extra: insights
 Requires-Dist: pyarrow; extra == "insights"
 Provides-Extra: docker
 Requires-Dist: docker; extra == "docker"
-Requires-Dist: dagster-docker==0.26.11; extra == "docker"
+Requires-Dist: dagster-docker==0.28.6; extra == "docker"
 Provides-Extra: kubernetes
 Requires-Dist: kubernetes; extra == "kubernetes"
-Requires-Dist: dagster-k8s==0.26.11; extra == "kubernetes"
+Requires-Dist: dagster-k8s==0.28.6; extra == "kubernetes"
 Provides-Extra: ecs
-Requires-Dist: dagster-aws==0.26.11; extra == "ecs"
+Requires-Dist: dagster-aws==0.28.6; extra == "ecs"
 Requires-Dist: boto3; extra == "ecs"
 Provides-Extra: sandbox
 Requires-Dist: supervisor; extra == "sandbox"