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

dagster_cloud/storage/compute_logs/compute_log_manager.py

@@ -1,5 +1,6 @@
+import os
 from collections.abc import Sequence
-from typing import TYPE_CHECKING, Any, Optional
+from typing import IO, TYPE_CHECKING, Any, Optional
 
 import requests
 from dagster import (
@@ -8,14 +9,15 @@ from dagster import (
     StringSource,
     _check as check,
 )
-from dagster._core.storage.cloud_storage_compute_log_manager import CloudStorageComputeLogManager
+from dagster._core.storage.cloud_storage_compute_log_manager import (
+    TruncatingCloudStorageComputeLogManager,
+)
 from dagster._core.storage.compute_log_manager import ComputeIOType
 from dagster._core.storage.local_compute_log_manager import (
     IO_TYPE_EXTENSION,
     LocalComputeLogManager,
 )
 from dagster._serdes import ConfigurableClass, ConfigurableClassData
-from dagster._utils import ensure_file
 from dagster_cloud_cli.core.errors import raise_http_error
 from dagster_cloud_cli.core.headers.auth import DagsterCloudInstanceScope
 from dagster_shared import seven
@@ -27,7 +29,7 @@ if TYPE_CHECKING:
 
 
 class CloudComputeLogManager(
-    CloudStorageComputeLogManager["DagsterCloudAgentInstance"], ConfigurableClass
+    TruncatingCloudStorageComputeLogManager["DagsterCloudAgentInstance"], ConfigurableClass
 ):
     def __init__(
         self,
@@ -47,6 +49,7 @@ class CloudComputeLogManager(
         self._local_manager = LocalComputeLogManager(local_dir)
         self._upload_interval = check.opt_int_param(upload_interval, "upload_interval")
         self._inst_data = check.opt_inst_param(inst_data, "inst_data", ConfigurableClassData)
+        super().__init__()
 
     @property
     def inst_data(self):
@@ -88,17 +91,19 @@ class CloudComputeLogManager(
         """Returns whether the cloud storage contains logs for a given log key."""
         return False
 
-    def upload_to_cloud_storage(
-        self, log_key: Sequence[str], io_type: ComputeIOType, partial=False
+    def _upload_file_obj(
+        self, data: IO[bytes], log_key: Sequence[str], io_type: ComputeIOType, partial=False
     ):
         path = self.local_manager.get_captured_local_path(log_key, IO_TYPE_EXTENSION[io_type])
-        ensure_file(path)
+        size_bytes = os.stat(path).st_size
         params: dict[str, Any] = {
             "log_key": log_key,
             "io_type": io_type.value,
+            "size_bytes": size_bytes,
             # for back-compat
             "run_id": log_key[0],
             "key": log_key[-1],
+            "method": "PUT",
         }
         if partial:
             params["partial"] = True
@@ -115,12 +120,11 @@ class CloudComputeLogManager(
         if resp_data.get("skip_upload"):
             return
 
-        with open(path, "rb") as f:
-            self._upload_session.post(
-                resp_data["url"],
-                data=resp_data["fields"],
-                files={"file": f},
-            )
+        self._upload_session.put(
+            resp_data["url"],
+            data=data,
+            timeout=self._instance.dagster_cloud_api_timeout,
+        )
 
     def download_from_cloud_storage(
         self, log_key: Sequence[str], io_type: ComputeIOType, partial=False

dagster_cloud/storage/defs_state/__init__.py

@@ -0,0 +1,3 @@
+from dagster_cloud.storage.defs_state.storage import (
+    GraphQLDefsStateStorage as GraphQLDefsStateStorage,
+)

dagster_cloud/storage/defs_state/queries.py

@@ -0,0 +1,15 @@
+GET_LATEST_DEFS_STATE_INFO_QUERY = """
+    query getLatestDefsStateInfo {
+        latestDefsStateInfo
+    }
+"""
+
+SET_LATEST_VERSION_MUTATION = """
+    mutation setLatestDefsStateVersion($key: String!, $version: String!) {
+        defsState {
+            setLatestDefsStateVersion(key: $key, version: $version) {
+                ok
+            }
+        }
+    }
+"""

dagster_cloud/storage/defs_state/storage.py

@@ -0,0 +1,113 @@
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Optional
+
+import dagster._check as check
+from dagster._core.storage.defs_state.base import DefsStateStorage
+from dagster._serdes import ConfigurableClass, ConfigurableClassData
+from dagster_cloud_cli.core.artifacts import download_artifact, upload_artifact
+from dagster_cloud_cli.core.headers.auth import DagsterCloudInstanceScope
+from dagster_shared.serdes import deserialize_value
+from dagster_shared.serdes.objects.models.defs_state_info import DefsStateInfo
+from typing_extensions import Self
+
+if TYPE_CHECKING:
+    from dagster_cloud.instance import DagsterCloudAgentInstance  # noqa: F401
+
+GET_LATEST_DEFS_STATE_INFO_QUERY = """
+    query getLatestDefsStateInfo {
+        latestDefsStateInfo
+    }
+"""
+
+SET_LATEST_VERSION_MUTATION = """
+    mutation setLatestDefsStateVersion($key: String!, $version: String!) {
+        defsState {
+            setLatestDefsStateVersion(key: $key, version: $version) {
+                ok
+            }
+        }
+    }
+"""
+
+
+class GraphQLDefsStateStorage(DefsStateStorage["DagsterCloudAgentInstance"], ConfigurableClass):
+    def __init__(
+        self, inst_data: Optional[ConfigurableClassData] = None, override_graphql_client=None
+    ):
+        """Initialize this class directly only for test (using `override_graphql_client`).
+        Use the ConfigurableClass machinery to init from instance yaml.
+        """
+        self._inst_data = check.opt_inst_param(inst_data, "inst_data", ConfigurableClassData)
+        self._override_graphql_client = override_graphql_client
+
+    @property
+    def inst_data(self):
+        return self._inst_data
+
+    @classmethod
+    def config_type(cls):
+        return {}
+
+    @classmethod
+    def from_config_value(cls, inst_data: ConfigurableClassData, config_value: Any) -> Self:
+        return cls(inst_data=inst_data)
+
+    @property
+    def url(self) -> str:
+        return self._instance.dagster_cloud_url
+
+    @property
+    def api_token(self) -> str:
+        return check.not_none(self._instance.dagster_cloud_agent_token)
+
+    @property
+    def deployment(self) -> str:
+        return check.not_none(self._instance.deployment_name)
+
+    @property
+    def graphql_client(self):
+        return (
+            self._override_graphql_client
+            if self._override_graphql_client
+            else self._instance.graphql_client
+        )
+
+    def _execute_query(self, query, variables=None, idempotent_mutation=False):
+        return self.graphql_client.execute(
+            query, variable_values=variables, idempotent_mutation=idempotent_mutation
+        )
+
+    def _get_artifact_key(self, key: str, version: str) -> str:
+        return f"__state__/{self._sanitize_key(key)}/{version}"
+
+    def download_state_to_path(self, key: str, version: str, path: Path) -> None:
+        download_artifact(
+            url=self.url,
+            scope=DagsterCloudInstanceScope.DEPLOYMENT,
+            api_token=self.api_token,
+            key=self._get_artifact_key(key, version),
+            path=path,
+            deployment=self.deployment,
+        )
+
+    def upload_state_from_path(self, key: str, version: str, path: Path) -> None:
+        upload_artifact(
+            url=self.url,
+            scope=DagsterCloudInstanceScope.DEPLOYMENT,
+            api_token=self.api_token,
+            key=self._get_artifact_key(key, version),
+            path=path,
+            deployment=self.deployment,
+        )
+        self.set_latest_version(key, version)
+
+    def get_latest_defs_state_info(self) -> Optional[DefsStateInfo]:
+        res = self._execute_query(GET_LATEST_DEFS_STATE_INFO_QUERY)
+        result = res["data"]["latestDefsStateInfo"]
+        if result is not None:
+            return deserialize_value(result, DefsStateInfo)
+        else:
+            return None
+
+    def set_latest_version(self, key: str, version: str) -> None:
+        self._execute_query(SET_LATEST_VERSION_MUTATION, variables={"key": key, "version": version})

dagster_cloud/storage/event_logs/__init__.py

@@ -1 +1,3 @@
-from .storage import GraphQLEventLogStorage as GraphQLEventLogStorage
+from dagster_cloud.storage.event_logs.storage import (
+    GraphQLEventLogStorage as GraphQLEventLogStorage,
+)

dagster_cloud/storage/event_logs/storage.py

@@ -11,6 +11,7 @@ import dagster._check as check
 from dagster import AssetCheckKey, DagsterInvalidInvocationError, PartitionsDefinition
 from dagster._core.assets import AssetDetails
 from dagster._core.definitions.events import AssetKey, ExpectationResult
+from dagster._core.definitions.freshness import FreshnessStateRecord
 from dagster._core.event_api import (
     AssetRecordsFilter,
     EventLogRecord,
@@ -67,7 +68,7 @@ if TYPE_CHECKING:
 DEFAULT_RUN_SCOPED_EVENT_TAILER_OFFSET = 20000
 
 
-from .queries import (
+from dagster_cloud.storage.event_logs.queries import (
     ADD_DYNAMIC_PARTITIONS_MUTATION,
     CHECK_CONCURRENCY_CLAIM_QUERY,
     CLAIM_CONCURRENCY_SLOT_MUTATION,
@@ -624,6 +625,7 @@ class GraphQLEventLogStorage(EventLogStorage, ConfigurableClass):
                     if event.dagster_event is not None
                     else "user",
                 )
+                event_span.set_attribute("run_id", event.run_id)
                 yield
 
     def store_event(self, event: EventLogEntry):
@@ -778,6 +780,11 @@ class GraphQLEventLogStorage(EventLogStorage, ConfigurableClass):
             for result in res["data"]["eventLogs"]["getAssetRecords"]
         ]
 
+    def get_freshness_state_records(
+        self, keys: Sequence[AssetKey]
+    ) -> Mapping[AssetKey, FreshnessStateRecord]:
+        raise NotImplementedError("Not callable from user cloud")
+
     def has_asset_key(self, asset_key: AssetKey):
         check.inst_param(asset_key, "asset_key", AssetKey)
 
@@ -950,7 +957,7 @@ class GraphQLEventLogStorage(EventLogStorage, ConfigurableClass):
         ]
 
         # Translate list to tuple
-        return {key: tuple(val) for key, val in result.items()}  # type: ignore
+        return {key: tuple(val) for key, val in result.items()}
 
     def get_event_tags_for_asset(
         self,

dagster_cloud/storage/event_logs/utils.py

@@ -11,9 +11,7 @@ from dagster._core.events import (
     StepRetryData,
 )
 from dagster._core.events.log import EventLogEntry
-from dagster._utils.error import SerializableErrorInfo
-
-from dagster_cloud.util.errors import truncate_serialized_error
+from dagster._utils.error import SerializableErrorInfo, truncate_serialized_error
 
 
 def _get_error_character_size_limit() -> int:

dagster_cloud/storage/runs/__init__.py

@@ -1 +1 @@
-from .storage import GraphQLRunStorage as GraphQLRunStorage
+from dagster_cloud.storage.runs.storage import GraphQLRunStorage as GraphQLRunStorage

dagster_cloud/storage/runs/queries.py

@@ -43,6 +43,21 @@ ADD_RUN_MUTATION = (
 """
 )
 
+ADD_HISTORICAL_RUN_MUTATION = (
+    ERROR_FRAGMENT
+    + """
+    mutation addHistoricalRunMutation($serializedPipelineRun: String!, $runCreationTime: Float!) {
+        runs {
+            addHistoricalRun(serializedPipelineRun: $serializedPipelineRun, runCreationTime: $runCreationTime) {
+                ok
+                error {
+                    ...errorFragment
+                }
+            }
+        }
+    }
+    """
+)
 
 GET_RUNS_QUERY = """
     query getRunsQuery($filters: RunsFilter, $cursor: String, $limit: Int, $bucketBy: RunBucket, $ascending: Boolean) {

dagster_cloud/storage/runs/storage.py

@@ -1,5 +1,6 @@
 import json
 from collections.abc import Iterable, Mapping, Sequence
+from datetime import datetime
 from typing import Any, Callable, Optional, Union
 
 import dagster._check as check
@@ -12,7 +13,7 @@ from dagster._core.errors import (
 from dagster._core.events import DagsterEvent
 from dagster._core.execution.backfill import BulkActionsFilter, BulkActionStatus, PartitionBackfill
 from dagster._core.execution.telemetry import RunTelemetryData
-from dagster._core.remote_representation.origin import RemoteJobOrigin
+from dagster._core.remote_origin import RemoteJobOrigin
 from dagster._core.snap import ExecutionPlanSnapshot, JobSnap, create_execution_plan_snapshot_id
 from dagster._core.storage.dagster_run import (
     DagsterRun,
@@ -35,10 +36,11 @@ from dagster._utils.merger import merge_dicts
 from dagster_cloud_cli.core.errors import DagsterCloudAgentServerError
 from typing_extensions import Self
 
-from .queries import (
+from dagster_cloud.storage.runs.queries import (
     ADD_BACKFILL_MUTATION,
     ADD_DAEMON_HEARTBEAT_MUTATION,
     ADD_EXECUTION_PLAN_SNAPSHOT_MUTATION,
+    ADD_HISTORICAL_RUN_MUTATION,
     ADD_PIPELINE_SNAPSHOT_MUTATION,
     ADD_RUN_MUTATION,
     ADD_RUN_TAGS_MUTATION,
@@ -190,6 +192,29 @@ class GraphQLRunStorage(RunStorage, ConfigurableClass):
             query, variable_values=variables, idempotent_mutation=idempotent_mutation
         )
 
+    def add_historical_run(
+        self, dagster_run: DagsterRun, run_creation_time: datetime
+    ) -> DagsterRun:
+        check.inst_param(dagster_run, "dagster_run", DagsterRun)
+        res = self._execute_query(
+            ADD_HISTORICAL_RUN_MUTATION,
+            variables={
+                "serializedPipelineRun": serialize_value(dagster_run),
+                "runCreationTime": run_creation_time.timestamp(),
+            },
+        )
+        result = res["data"]["runs"]["addHistoricalRun"]
+        error = result.get("error")
+        # Special-case some errors to match the RunStorage API
+        if error:
+            if error["className"] == "DagsterRunAlreadyExists":
+                raise DagsterRunAlreadyExists(error["message"])
+            if error["className"] == "DagsterSnapshotDoesNotExist":
+                raise DagsterSnapshotDoesNotExist(error["message"])
+            else:
+                raise DagsterCloudAgentServerError(res)
+        return dagster_run
+
     def add_run(self, dagster_run: DagsterRun):
         check.inst_param(dagster_run, "dagster_run", DagsterRun)
         res = self._execute_query(
@@ -211,7 +236,9 @@ class GraphQLRunStorage(RunStorage, ConfigurableClass):
 
         return dagster_run
 
-    def handle_run_event(self, run_id: str, event: DagsterEvent):
+    def handle_run_event(
+        self, run_id: str, event: DagsterEvent, update_timestamp: Optional[datetime] = None
+    ):
         raise NotImplementedError("Should never be called by an agent client")
 
     @property

dagster_cloud/storage/schedules/__init__.py

@@ -1 +1 @@
-from .storage import GraphQLScheduleStorage as GraphQLScheduleStorage
+from dagster_cloud.storage.schedules.storage import GraphQLScheduleStorage as GraphQLScheduleStorage

dagster_cloud/storage/schedules/storage.py

@@ -24,7 +24,7 @@ from dagster._serdes import (
 )
 from typing_extensions import Self
 
-from .queries import (
+from dagster_cloud.storage.schedules.queries import (
     ADD_JOB_STATE_MUTATION,
     ALL_STORED_JOB_STATE_QUERY,
     CREATE_JOB_TICK_MUTATION,

dagster_cloud/util/errors.py

@@ -1,98 +1,7 @@
 from collections.abc import Sequence
-from typing import Optional
 
-from dagster._serdes import serialize_value
 from dagster._utils.error import SerializableErrorInfo
 
-ERROR_CLASS_NAME_SIZE_LIMIT = 1000
-
-
-def unwrap_user_code_error(error_info: SerializableErrorInfo) -> SerializableErrorInfo:
-    """Extracts the underlying error from the passed error, if it is a DagsterUserCodeLoadError."""
-    if error_info.cls_name == "DagsterUserCodeLoadError":
-        return unwrap_user_code_error(error_info.cause)
-    return error_info
-
-
-def truncate_serialized_error(
-    error_info: SerializableErrorInfo,
-    field_size_limit: int,
-    max_depth: int,
-    truncations: Optional[list[str]] = None,
-):
-    truncations = [] if truncations is None else truncations
-
-    if error_info.cause:
-        if max_depth == 0:
-            truncations.append("cause")
-            new_cause = (
-                error_info.cause
-                if len(serialize_value(error_info.cause)) <= field_size_limit
-                else SerializableErrorInfo(
-                    message="(Cause truncated due to size limitations)",
-                    stack=[],
-                    cls_name=None,
-                )
-            )
-        else:
-            new_cause = truncate_serialized_error(
-                error_info.cause,
-                field_size_limit,
-                max_depth=max_depth - 1,
-                truncations=truncations,
-            )
-        error_info = error_info._replace(cause=new_cause)
-
-    if error_info.context:
-        if max_depth == 0:
-            truncations.append("context")
-            new_context = (
-                error_info.context
-                if len(serialize_value(error_info.context)) <= field_size_limit
-                else SerializableErrorInfo(
-                    message="(Context truncated due to size limitations)",
-                    stack=[],
-                    cls_name=None,
-                )
-            )
-        else:
-            new_context = truncate_serialized_error(
-                error_info.context,
-                field_size_limit,
-                max_depth=max_depth - 1,
-                truncations=truncations,
-            )
-        error_info = error_info._replace(context=new_context)
-
-    stack_size_so_far = 0
-    truncated_stack = []
-    for stack_elem in error_info.stack:
-        stack_size_so_far += len(stack_elem)
-        if stack_size_so_far > field_size_limit:
-            truncations.append("stack")
-            truncated_stack.append("(TRUNCATED)")
-            break
-
-        truncated_stack.append(stack_elem)
-
-    error_info = error_info._replace(stack=truncated_stack)
-
-    msg_len = len(error_info.message)
-    if msg_len > field_size_limit:
-        truncations.append(f"message from {msg_len} to {field_size_limit}")
-        error_info = error_info._replace(
-            message=error_info.message[:field_size_limit] + " (TRUNCATED)"
-        )
-
-    if error_info.cls_name and len(error_info.cls_name) > ERROR_CLASS_NAME_SIZE_LIMIT:
-        truncations.append("cls_name")
-        error_info = error_info._replace(
-            cls_name=error_info.cls_name[:ERROR_CLASS_NAME_SIZE_LIMIT] + " (TRUNCATED)"
-        )
-
-    return error_info
-
-
 DAGSTER_FRAMEWORK_SUBSTRINGS = [
     "/site-packages/dagster/",
     "/python_modules/dagster/dagster",

dagster_cloud/version.py

@@ -1 +1 @@
-__version__ = "1.10.11"
+__version__ = "1.12.6"

dagster_cloud/workspace/config_schema/__init__.py

@@ -13,12 +13,12 @@ from dagster import (
 )
 from dagster._config import EvaluationError, StringSource, validate_config
 
-from .docker import SHARED_DOCKER_CONFIG
-from .ecs import (
+from dagster_cloud.workspace.config_schema.docker import SHARED_DOCKER_CONFIG
+from dagster_cloud.workspace.config_schema.ecs import (
     ECS_CONTAINER_CONTEXT_CONFIG as ECS_CONTAINER_CONTEXT_CONFIG,
     SHARED_ECS_CONFIG as SHARED_ECS_CONFIG,
 )
-from .kubernetes import SHARED_K8S_CONFIG
+from dagster_cloud.workspace.config_schema.kubernetes import SHARED_K8S_CONFIG
 
 
 def validate_workspace_location(workspace_location) -> Optional[list[str]]:
@@ -62,8 +62,21 @@ def process_workspace_config(workspace_config) -> dict[str, Any]:
             python_file = config.get("python_file")
             package_name = config.get("package_name")
             module_name = config.get("module_name")
+            autoload_defs_module_name = config.get("autoload_defs_module_name")
             check.invariant(
-                len([val for val in [python_file, package_name, module_name] if val]) == 1,
+                len(
+                    [
+                        val
+                        for val in [
+                            python_file,
+                            package_name,
+                            module_name,
+                            autoload_defs_module_name,
+                        ]
+                        if val
+                    ]
+                )
+                == 1,
                 "Must supply exactly one of a file name, a package name, or a module name",
             )
 
@@ -73,7 +86,8 @@ def process_workspace_config(workspace_config) -> dict[str, Any]:
             new_location = {
                 k: v
                 for k, v in location.items()
-                if k not in ("python_file", "package_name", "module_name")
+                if k
+                not in ("python_file", "package_name", "module_name", "autoload_defs_module_name")
             }
             new_location["code_source"] = {}
             if "python_file" in location:
@@ -82,6 +96,10 @@ def process_workspace_config(workspace_config) -> dict[str, Any]:
                 new_location["code_source"]["package_name"] = location["package_name"]
             elif "module_name" in location:
                 new_location["code_source"]["module_name"] = location["module_name"]
+            elif "autoload_defs_module_name" in location:
+                new_location["code_source"]["autoload_defs_module_name"] = location[
+                    "autoload_defs_module_name"
+                ]
 
             new_location["location_name"] = name
             updated_locations.append(new_location)
@@ -194,6 +212,10 @@ CONFIG_SCHEMA_FIELDS = {
                     config=str,
                     description="Python module containing the target Dagster repository.",
                 ),
+                "autoload_defs_module_name": Field(
+                    config=str,
+                    description="Python module to automatically load Dagster definitions from.",
+                ),
             },
         ),
         description="Python entry point for the code location.",
@@ -254,6 +276,17 @@ CONFIG_SCHEMA_FIELDS = {
         is_required=False,
         description="Locations that specify an agent queue will only have their requests handled by agents configured to read from a matching queue. By default, requests are placed on a default queue that's handled by all agents.",
     ),
+    "defs_state_info": Field(
+        config=Shape(
+            fields={
+                "info_mapping": Map(
+                    str, Noneable(Shape(fields={"version": str, "create_timestamp": float}))
+                )
+            },
+        ),
+        is_required=False,
+        description="Defs state info for the code location.",
+    ),
 }
 
 
@@ -282,6 +315,11 @@ LEGACY_CONFIG_SCHEMA_FIELDS = {
         is_required=False,
         description="Python module containing the target Dagster repository.",
     ),
+    "autoload_defs_module_name": Field(
+        config=str,
+        is_required=False,
+        description="Python module to automatically load Dagster definitions from.",
+    ),
 }
 LEGACY_LOCATION_CONFIG_SCHEMA = Shape(fields=LEGACY_CONFIG_SCHEMA_FIELDS)
 LEGACY_NAMED_LOCATIONS_CONFIG_SCHEMA = Map(

dagster_cloud/workspace/docker/__init__.py

@@ -28,19 +28,20 @@ from typing_extensions import Self
 from dagster_cloud.api.dagster_cloud_api import UserCodeDeploymentType
 from dagster_cloud.execution.monitoring import CloudContainerResourceLimits
 from dagster_cloud.storage.tags import PEX_METADATA_TAG
-from dagster_cloud.workspace.user_code_launcher.user_code_launcher import UserCodeLauncherEntry
-from dagster_cloud.workspace.user_code_launcher.utils import get_grpc_server_env
-
-from ..config_schema.docker import SHARED_DOCKER_CONFIG
-from ..user_code_launcher import (
+from dagster_cloud.workspace.config_schema.docker import SHARED_DOCKER_CONFIG
+from dagster_cloud.workspace.docker.utils import unique_docker_resource_name
+from dagster_cloud.workspace.user_code_launcher import (
     DEFAULT_SERVER_PROCESS_STARTUP_TIMEOUT,
     SHARED_USER_CODE_LAUNCHER_CONFIG,
     DagsterCloudGrpcServer,
     DagsterCloudUserCodeLauncher,
     ServerEndpoint,
 )
-from ..user_code_launcher.utils import deterministic_label_for_location
-from .utils import unique_docker_resource_name
+from dagster_cloud.workspace.user_code_launcher.user_code_launcher import UserCodeLauncherEntry
+from dagster_cloud.workspace.user_code_launcher.utils import (
+    deterministic_label_for_location,
+    get_grpc_server_env,
+)
 
 GRPC_SERVER_LABEL = "dagster_grpc_server"
 MULTIPEX_SERVER_LABEL = "dagster_multipex_server"

dagster_cloud/workspace/docker/utils.py

@@ -1,6 +1,6 @@
 import re
 
-from ..user_code_launcher.utils import unique_resource_name
+from dagster_cloud.workspace.user_code_launcher.utils import unique_resource_name
 
 
 def unique_docker_resource_name(deployment_name, location_name):

dagster_cloud/workspace/ecs/__init__.py

@@ -1 +1 @@
-from .launcher import EcsUserCodeLauncher as EcsUserCodeLauncher
+from dagster_cloud.workspace.ecs.launcher import EcsUserCodeLauncher as EcsUserCodeLauncher