dagster 1.11.15__tar.gz → 1.11.16__tar.gz

{dagster-1.11.15/dagster.egg-info → dagster-1.11.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dagster
-Version: 1.11.15
+Version: 1.11.16
 Summary: Dagster is an orchestration platform for the development, production, and observation of data assets.
 Author: Dagster Labs
 Author-email: hello@dagsterlabs.com
@@ -60,8 +60,8 @@ Requires-Dist: universal_pathlib; python_version < "3.12"
 Requires-Dist: universal_pathlib>=0.2.0; python_version >= "3.12"
 Requires-Dist: rich
 Requires-Dist: filelock
-Requires-Dist: dagster-pipes==1.11.15
-Requires-Dist: dagster-shared==1.11.15
+Requires-Dist: dagster-pipes==1.11.16
+Requires-Dist: dagster-shared==1.11.16
 Requires-Dist: antlr4-python3-runtime
 Provides-Extra: docker
 Requires-Dist: docker; extra == "docker"

dagster-1.11.16/dagster/_api/snapshot_repository.py

@@ -0,0 +1,88 @@
+import os
+from collections.abc import Mapping
+from concurrent.futures import ThreadPoolExecutor
+from typing import TYPE_CHECKING
+
+import dagster._check as check
+from dagster._core.errors import DagsterUserCodeProcessError
+from dagster._core.remote_representation.external_data import RepositoryErrorSnap, RepositorySnap
+from dagster._serdes import deserialize_value
+from dagster._utils.error import SerializableErrorInfo
+
+if TYPE_CHECKING:
+    from dagster._core.remote_representation.code_location import CodeLocation
+    from dagster._core.snap import JobSnap
+    from dagster._grpc.client import DagsterGrpcClient
+
+
+def sync_get_external_repositories_data_grpc(
+    api_client: "DagsterGrpcClient", code_location: "CodeLocation", defer_snapshots: bool
+) -> Mapping[str, tuple[RepositorySnap, Mapping[str, "JobSnap"]]]:
+    from dagster._core.remote_origin import RemoteRepositoryOrigin
+    from dagster._core.remote_representation.code_location import CodeLocation
+    from dagster._core.remote_representation.external_data import (
+        extract_serialized_job_snap_from_serialized_job_data_snap,
+    )
+    from dagster._core.snap import JobSnap
+
+    check.inst_param(code_location, "code_location", CodeLocation)
+
+    repo_datas = {}
+    for repository_name in code_location.repository_names:  # type: ignore
+        repo_origin = RemoteRepositoryOrigin(
+            code_location.origin,
+            repository_name,
+        )
+        result = deserialize_value(
+            api_client.external_repository(
+                remote_repository_origin=RemoteRepositoryOrigin(
+                    code_location.origin,
+                    repository_name,
+                ),
+                defer_snapshots=defer_snapshots,
+            ),
+            (RepositorySnap, RepositoryErrorSnap),
+        )
+
+        if isinstance(result, RepositoryErrorSnap):
+            raise DagsterUserCodeProcessError.from_error_info(result.error)
+
+        job_snaps = {}
+
+        if not result.has_job_data():
+            job_refs = result.get_job_refs()
+            with ThreadPoolExecutor(
+                max_workers=int(os.getenv("DAGSTER_EXTERNAL_JOB_THREADPOOL_WORKERS", "4"))
+            ) as executor:
+                job_responses = list(
+                    executor.map(
+                        lambda job_ref: api_client.external_job(
+                            repo_origin,
+                            job_ref.name,
+                        ),
+                        job_refs,
+                    )
+                )
+
+            for i, job_ref in enumerate(job_refs):
+                job_response = job_responses[i]
+                if not job_response.serialized_job_data:
+                    error = (
+                        deserialize_value(job_response.serialized_error, SerializableErrorInfo)
+                        if job_response.serialized_error
+                        else "no captured error"
+                    )
+                    raise Exception(
+                        f"Error fetching job data for {job_ref.name} in code server:\n{error}"
+                    )
+                job_snap = deserialize_value(
+                    extract_serialized_job_snap_from_serialized_job_data_snap(
+                        job_response.serialized_job_data
+                    ),
+                    JobSnap,
+                )
+
+                job_snaps[job_ref.name] = job_snap
+
+        repo_datas[repository_name] = result, job_snaps
+    return repo_datas

{dagster-1.11.15 → dagster-1.11.16}/dagster/_cli/code_server.py

@@ -25,7 +25,9 @@ def get_default_proxy_server_heartbeat_timeout():
     return int(os.getenv("DAGSTER_PROXY_SERVER_HEARTBEAT_TIMEOUT", "30"))
 
 
-DEFAULT_HEARTBEAT_TIMEOUT = get_default_proxy_server_heartbeat_timeout()
+def get_default_grpc_proxy_heartbeat_ttl():
+    """Get the default heartbeat TTL for the gRPC proxy server."""
+    return int(os.getenv("DAGSTER_GRPC_PROXY_HEARTBEAT_TTL_SECONDS", "30"))
 
 
 @click.group(name="code-server")
@@ -162,9 +164,17 @@ def code_server_cli():
     "--heartbeat-timeout",
     type=click.INT,
     required=False,
-    default=DEFAULT_HEARTBEAT_TIMEOUT,
+    default=get_default_proxy_server_heartbeat_timeout(),
     help="How long to wait for a heartbeat from the caller before timing out. Only comes into play if --heartbeat is set. Defaults to 30 seconds.",
 )
+@click.option(
+    "--heartbeat-ttl",
+    type=click.INT,
+    required=False,
+    default=get_default_grpc_proxy_heartbeat_ttl(),
+    help="How long spawned API server processes will wait without receiving a heartbeat from clients before shutting down. This is separate from --heartbeat-timeout, which controls how long the proxy server itself waits for heartbeats from its caller. Defaults to 30 seconds.",
+    envvar="DAGSTER_GRPC_PROXY_HEARTBEAT_TTL_SECONDS",
+)
 @click.option(
     "--instance-ref",
     type=click.STRING,
@@ -194,7 +204,8 @@ def start_command(
     location_name: Optional[str],
     startup_timeout: int,
     heartbeat: bool,
-    heartbeat_timeout,
+    heartbeat_timeout: int,
+    heartbeat_ttl: int,
     instance_ref: Optional[str],
     defs_state_info: Optional[str],
     **other_opts,
@@ -266,6 +277,7 @@ def start_command(
         logger=logger,
         server_heartbeat=heartbeat,
         server_heartbeat_timeout=heartbeat_timeout,
+        heartbeat_ttl=heartbeat_ttl,
         defs_state_info=deserialize_value(defs_state_info, DefsStateInfo)
         if defs_state_info
         else None,

{dagster-1.11.15 → dagster-1.11.16}/dagster/_core/definitions/definitions_load_context.py

@@ -23,7 +23,7 @@ from dagster._core.definitions.definitions_class import Definitions
 from dagster._core.definitions.metadata.metadata_value import (
     CodeLocationReconstructionMetadataValue,
 )
-from dagster._core.errors import DagsterInvariantViolationError
+from dagster._core.errors import DagsterInvalidInvocationError, DagsterInvariantViolationError
 from dagster._core.storage.defs_state.base import DefsStateStorage
 from dagster.components.utils.defs_state import DefsStateConfig
 from dagster.components.utils.project_paths import (
@@ -195,7 +195,7 @@ class DefinitionsLoadContext:
 
     @contextmanager
     def state_path(
-        self, config: DefsStateConfig, state_storage: DefsStateStorage, project_root: Path
+        self, config: DefsStateConfig, state_storage: Optional[DefsStateStorage], project_root: Path
     ) -> Iterator[Optional[Path]]:
         """Context manager that creates a temporary path to hold local state for a component.
 
@@ -218,6 +218,11 @@ class DefinitionsLoadContext:
             self.add_defs_state_info(key, LOCAL_STATE_VERSION, state_path.stat().st_ctime)
             yield state_path
         elif config.type == DefsStateManagementType.VERSIONED_STATE_STORAGE:
+            if state_storage is None:
+                raise DagsterInvalidInvocationError(
+                    f"Attempted to access state for key {config.key} with management type {config.type} "
+                    "without a StateStorage in context. This is likely the result of an internal framework error."
+                )
             key_info = self._get_defs_key_state_info(key)
             # this implies that no state has been stored since the management type was changed
             if key_info is None or key_info.management_type != config.type:

{dagster-1.11.15 → dagster-1.11.16}/dagster/_core/definitions/repository_definition/caching_index.py

@@ -54,6 +54,15 @@ class CacheingDefinitionIndex(Generic[T_RepositoryLevelDefinition]):
 
         self._all_definitions: Optional[Sequence[T_RepositoryLevelDefinition]] = None
 
+    def _validate_definition_key(
+        self, definition: T_RepositoryLevelDefinition, definition_dict_key: str
+    ):
+        check.invariant(
+            definition.name == definition_dict_key,
+            f"Bad constructor for {self._definition_kind} '{definition_dict_key}': name in "
+            f"{self._definition_class_name} does not match: got '{definition.name}'",
+        )
+
     def _get_lazy_definitions(self) -> Sequence[T_RepositoryLevelDefinition]:
         if self._lazy_definitions is None:
             self._lazy_definitions = self._lazy_definitions_fn()
@@ -118,10 +127,13 @@ class CacheingDefinitionIndex(Generic[T_RepositoryLevelDefinition]):
         definition_source = self._definitions[definition_name]
 
         if isinstance(definition_source, self._definition_class):
-            self._definition_cache[definition_name] = self._validation_fn(definition_source)
+            definition = self._validation_fn(definition_source)
+            self._validate_definition_key(definition, definition_name)
+            self._definition_cache[definition_name] = definition
             return definition_source
         else:
             definition = cast("Callable", definition_source)()
+            self._validate_definition_key(definition, definition_name)
             self._validate_and_cache_definition(definition, definition_name)
             return definition
 
@@ -133,9 +145,5 @@ class CacheingDefinitionIndex(Generic[T_RepositoryLevelDefinition]):
             f"Bad constructor for {self._definition_kind} {definition_dict_key}: must return "
             f"{self._definition_class_name}, got value of type {type(definition)}",
         )
-        check.invariant(
-            definition.name == definition_dict_key,
-            f"Bad constructor for {self._definition_kind} '{definition_dict_key}': name in "
-            f"{self._definition_class_name} does not match: got '{definition.name}'",
-        )
+
         self._definition_cache[definition_dict_key] = self._validation_fn(definition)

{dagster-1.11.15 → dagster-1.11.16}/dagster/_core/definitions/selector.py

@@ -228,6 +228,14 @@ class ScheduleSelector:
             schedule_name=graphql_data["scheduleName"],
         )
 
+    @staticmethod
+    def from_instigator_selector(selector: "InstigatorSelector"):
+        return ScheduleSelector(
+            location_name=selector.location_name,
+            repository_name=selector.repository_name,
+            schedule_name=selector.name,
+        )
+
 
 @record
 class ResourceSelector:
@@ -272,6 +280,14 @@ class SensorSelector:
             sensor_name=graphql_data["sensorName"],
         )
 
+    @staticmethod
+    def from_instigator_selector(selector: "InstigatorSelector"):
+        return SensorSelector(
+            location_name=selector.location_name,
+            repository_name=selector.repository_name,
+            sensor_name=selector.name,
+        )
+
     @property
     def instigator_name(self) -> str:
         return self.sensor_name

{dagster-1.11.15 → dagster-1.11.16}/dagster/_core/remote_representation/code_location.py

@@ -4,7 +4,7 @@ from abc import abstractmethod
 from collections.abc import Mapping, Sequence
 from contextlib import AbstractContextManager
 from functools import cached_property
-from typing import TYPE_CHECKING, Any, Optional, Union, cast
+from typing import TYPE_CHECKING, Any, Callable, Optional, Union, cast
 
 from dagster_shared.libraries import DagsterLibraryRegistry
 from dagster_shared.serdes.objects.models.defs_state_info import DefsStateInfo
@@ -64,6 +64,8 @@ if TYPE_CHECKING:
     from dagster._core.definitions.schedule_definition import ScheduleExecutionData
     from dagster._core.definitions.sensor_definition import SensorExecutionData
     from dagster._core.remote_representation.external_data import (
+        JobDataSnap,
+        JobRefSnap,
         PartitionConfigSnap,
         PartitionExecutionErrorSnap,
         PartitionSetExecutionParamSnap,
@@ -170,15 +172,24 @@ class CodeLocation(AbstractContextManager):
         if not selector.is_subset_selection:
             return self.get_repository(selector.repository_name).get_full_job(selector.job_name)
 
-        subset_result = self._get_subset_remote_job_result(selector)
+        subset_result = self._get_subset_remote_job_result(
+            selector,
+            lambda selector: self.get_repository(selector.repository_name).get_full_job(
+                selector.job_name
+            ),
+        )
         return self._get_remote_job_from_subset_result(selector, subset_result)
 
-    async def gen_subset_job(self, selector: JobSubsetSelector) -> RemoteJob:
-        subset_result = await self._gen_subset_remote_job_result(selector)
+    async def gen_subset_job(
+        self, selector: JobSubsetSelector, get_full_job: Callable[[JobSubsetSelector], RemoteJob]
+    ) -> RemoteJob:
+        subset_result = await self._gen_subset_remote_job_result(selector, get_full_job)
         return self._get_remote_job_from_subset_result(selector, subset_result)
 
     @abstractmethod
-    def _get_subset_remote_job_result(self, selector: JobSubsetSelector) -> RemoteJobSubsetResult:
+    def _get_subset_remote_job_result(
+        self, selector: JobSubsetSelector, get_full_job: Callable[[JobSubsetSelector], RemoteJob]
+    ) -> RemoteJobSubsetResult:
         """Returns a snapshot about an RemoteJob with an op selection, which requires
         access to the underlying JobDefinition. Callsites should likely use
         `get_job` instead.
@@ -186,7 +197,7 @@ class CodeLocation(AbstractContextManager):
 
     @abstractmethod
     async def _gen_subset_remote_job_result(
-        self, selector: JobSubsetSelector
+        self, selector: JobSubsetSelector, get_full_job: Callable[[JobSubsetSelector], RemoteJob]
     ) -> RemoteJobSubsetResult:
         """Returns a snapshot about an RemoteJob with an op selection, which requires
         access to the underlying JobDefinition. Callsites should likely use
@@ -424,11 +435,13 @@ class InProcessCodeLocation(CodeLocation):
         return self._repositories
 
     async def _gen_subset_remote_job_result(
-        self, selector: JobSubsetSelector
+        self, selector: JobSubsetSelector, get_full_job: Callable[[JobSubsetSelector], RemoteJob]
     ) -> RemoteJobSubsetResult:
-        return self._get_subset_remote_job_result(selector)
+        return self._get_subset_remote_job_result(selector, get_full_job)
 
-    def _get_subset_remote_job_result(self, selector: JobSubsetSelector) -> RemoteJobSubsetResult:
+    def _get_subset_remote_job_result(
+        self, selector: JobSubsetSelector, get_full_job: Callable[[JobSubsetSelector], RemoteJob]
+    ) -> RemoteJobSubsetResult:
         check.inst_param(selector, "selector", JobSubsetSelector)
         check.invariant(
             selector.location_name == self.name,
@@ -676,7 +689,6 @@ class GrpcServerCodeLocation(CodeLocation):
         self._watch_server = check.bool_param(watch_server, "watch_server")
 
         self._server_id = None
-        self._repository_snaps = None
 
         self._executable_path = None
         self._container_image = None
@@ -727,26 +739,45 @@ class GrpcServerCodeLocation(CodeLocation):
 
             self._container_context = list_repositories_response.container_context
 
-            self._repository_snaps = sync_get_external_repositories_data_grpc(
+            self._job_snaps = {}
+
+            self.remote_repositories = {}
+
+            for repo_name, (repo_data, job_snaps) in sync_get_external_repositories_data_grpc(
                 self.client,
                 self,
-            )
-
-            self.remote_repositories = {
-                repo_name: RemoteRepository(
+                defer_snapshots=True,
+            ).items():
+                self.remote_repositories[repo_name] = RemoteRepository(
                     repo_data,
                     RepositoryHandle.from_location(
                         repository_name=repo_name,
                         code_location=self,
                     ),
                     auto_materialize_use_sensors=instance.auto_materialize_use_sensors,
+                    ref_to_data_fn=self._job_ref_to_snap,
                 )
-                for repo_name, repo_data in self._repository_snaps.items()
-            }
+                for job_snap in job_snaps.values():
+                    self._job_snaps[job_snap.snapshot_id] = job_snap
+
         except:
             self.cleanup()
             raise
 
+    def _job_ref_to_snap(self, job_ref: "JobRefSnap") -> "JobDataSnap":
+        from dagster._core.remote_representation.external_data import JobDataSnap
+
+        snapshot = self._job_snaps[job_ref.snapshot_id]
+        parent_snapshot = (
+            self._job_snaps[job_ref.parent_snapshot_id] if job_ref.parent_snapshot_id else None
+        )
+        return JobDataSnap(
+            name=job_ref.name,
+            job=snapshot,
+            parent_job=parent_snapshot,
+            active_presets=job_ref.active_presets,
+        )
+
     @property
     def server_id(self) -> str:
         return check.not_none(self._server_id)
@@ -906,7 +937,9 @@ class GrpcServerCodeLocation(CodeLocation):
 
         return RemoteExecutionPlan(execution_plan_snapshot=execution_plan_snapshot_or_error)
 
-    def _get_subset_remote_job_result(self, selector: JobSubsetSelector) -> RemoteJobSubsetResult:
+    def _get_subset_remote_job_result(
+        self, selector: JobSubsetSelector, get_full_job: Callable[[JobSubsetSelector], RemoteJob]
+    ) -> RemoteJobSubsetResult:
         from dagster._api.snapshot_job import sync_get_external_job_subset_grpc
 
         check.inst_param(selector, "selector", JobSubsetSelector)
@@ -929,7 +962,7 @@ class GrpcServerCodeLocation(CodeLocation):
         # Omit the parent job snapshot for __ASSET_JOB, since it is potentialy very large
         # and unlikely to be useful (unlike subset selections of other jobs)
         if subset.job_data_snap and not is_implicit_asset_job_name(selector.job_name):
-            full_job = self.get_repository(selector.repository_name).get_full_job(selector.job_name)
+            full_job = get_full_job(selector)
             subset = copy(
                 subset,
                 job_data_snap=copy(subset.job_data_snap, parent_job=full_job.job_snapshot),
@@ -938,7 +971,7 @@ class GrpcServerCodeLocation(CodeLocation):
         return subset
 
     async def _gen_subset_remote_job_result(
-        self, selector: JobSubsetSelector
+        self, selector: JobSubsetSelector, get_full_job: Callable[[JobSubsetSelector], RemoteJob]
     ) -> "RemoteJobSubsetResult":
         from dagster._api.snapshot_job import gen_external_job_subset_grpc
 
@@ -960,7 +993,7 @@ class GrpcServerCodeLocation(CodeLocation):
             asset_check_selection=selector.asset_check_selection,
         )
         if subset.job_data_snap:
-            full_job = self.get_repository(selector.repository_name).get_full_job(selector.job_name)
+            full_job = get_full_job(selector)
             subset = copy(
                 subset,
                 job_data_snap=copy(subset.job_data_snap, parent_job=full_job.job_snapshot),

{dagster-1.11.15 → dagster-1.11.16}/dagster/_core/remote_representation/external.py

@@ -518,6 +518,8 @@ class RemoteJob(RepresentedJob, LoadableBy[JobSubsetSelector, "BaseWorkspaceRequ
 
     @property
     def owners(self) -> Optional[Sequence[str]]:
+        if self._job_ref_snap is not None:
+            return self._job_ref_snap.owners
         return getattr(self._job_index.job_snapshot, "owners", None)
 
     @property

{dagster-1.11.15 → dagster-1.11.16}/dagster/_core/remote_representation/external_data.py

@@ -223,6 +223,7 @@ class JobRefSnap:
     active_presets: Sequence["PresetSnap"]
     parent_snapshot_id: Optional[str]
     preview_tags: Optional[Mapping[str, str]] = None
+    owners: Optional[Sequence[str]] = None
 
     @classmethod
     def from_job_def(cls, job_def: JobDefinition) -> Self:
@@ -234,6 +235,7 @@ class JobRefSnap:
             parent_snapshot_id=None,
             active_presets=active_presets_from_job_def(job_def),
             preview_tags=get_preview_tags(job_def),
+            owners=job_def.owners,
         )
 
     def get_preview_tags(self) -> Mapping[str, str]:

{dagster-1.11.15 → dagster-1.11.16}/dagster/_core/scheduler/instigation.py

@@ -266,15 +266,17 @@ class InstigatorState(
         return self.origin.get_id()
 
     @property
-    def selector_id(self) -> str:
-        return create_snapshot_id(
-            InstigatorSelector(
-                location_name=self.origin.repository_origin.code_location_origin.location_name,
-                repository_name=self.origin.repository_origin.repository_name,
-                name=self.origin.instigator_name,
-            )
+    def selector(self) -> InstigatorSelector:
+        return InstigatorSelector(
+            location_name=self.origin.repository_origin.code_location_origin.location_name,
+            repository_name=self.origin.repository_origin.repository_name,
+            name=self.origin.instigator_name,
         )
 
+    @property
+    def selector_id(self) -> str:
+        return create_snapshot_id(self.selector)
+
     def with_status(self, status: InstigatorStatus) -> "InstigatorState":
         check.inst_param(status, "status", InstigatorStatus)
         return InstigatorState(

{dagster-1.11.15 → dagster-1.11.16}/dagster/_core/storage/event_log/base.py

@@ -73,6 +73,7 @@ class AssetEntry(
             ("last_planned_materialization_run_id", Optional[str]),
             ("last_failed_to_materialize_record", Optional[EventLogRecord]),
             ("is_writing_failures", bool),
+            ("last_skipped_materialize_record", Optional[EventLogRecord]),
         ],
     )
 ):
@@ -88,6 +89,7 @@ class AssetEntry(
         last_planned_materialization_run_id: Optional[str] = None,
         last_failed_to_materialize_record: Optional[EventLogRecord] = None,
         is_writing_failures: bool = False,
+        last_skipped_materialize_record: Optional[EventLogRecord] = None,
     ):
         from dagster._core.storage.partition_status_cache import AssetStatusCacheValue
 
@@ -121,6 +123,11 @@ class AssetEntry(
                 EventLogRecord,
             ),
             is_writing_failures=check.bool_param(is_writing_failures, "is_writing_failures"),
+            last_skipped_materialize_record=check.opt_inst_param(
+                last_skipped_materialize_record,
+                "last_skipped_materialize_record",
+                EventLogRecord,
+            ),
         )
 
     @property

{dagster-1.11.15 → dagster-1.11.16}/dagster/_core/workspace/context.py

@@ -395,7 +395,9 @@ class BaseWorkspaceRequestContext(LoadingContext):
         if not selector.is_subset_selection:
             return self.get_full_job(selector)
 
-        return await self.get_code_location(selector.location_name).gen_subset_job(selector)
+        return await self.get_code_location(selector.location_name).gen_subset_job(
+            selector, lambda selector: self.get_full_job(selector)
+        )
 
     def get_execution_plan(
         self,

{dagster-1.11.15 → dagster-1.11.16}/dagster/_grpc/proxy_server.py

@@ -58,6 +58,7 @@ class DagsterProxyApiServicer(DagsterApiServicer):
         logger: logging.Logger,
         server_heartbeat: bool,
         server_heartbeat_timeout: int,
+        heartbeat_ttl: int,
         defs_state_info: Optional[DefsStateInfo],
     ):
         super().__init__()
@@ -85,7 +86,7 @@ class DagsterProxyApiServicer(DagsterApiServicer):
             GrpcServerRegistry(
                 instance_ref=self._instance_ref,
                 server_command=GrpcServerCommand.API_GRPC,
-                heartbeat_ttl=30,
+                heartbeat_ttl=heartbeat_ttl,
                 startup_timeout=startup_timeout,
                 log_level=self._log_level,
                 inject_env_vars_from_instance=self._inject_env_vars_from_instance,

{dagster-1.11.15 → dagster-1.11.16}/dagster/_grpc/server.py

@@ -19,7 +19,7 @@ from typing import TYPE_CHECKING, Any, Callable, Optional, TypedDict, cast
 
 import dagster_shared.seven as seven
 import grpc
-from dagster_shared.error import remove_system_frames_from_error
+from dagster_shared.error import DagsterError, remove_system_frames_from_error
 from dagster_shared.ipc import open_ipc_subprocess
 from dagster_shared.libraries import DagsterLibraryRegistry
 from dagster_shared.serdes.objects.models.defs_state_info import DefsStateInfo
@@ -441,27 +441,23 @@ class DagsterApiServer(DagsterApiServicer):
         self._server_threadpool_executor = server_threadpool_executor
 
         try:
-            if inject_env_vars_from_instance:
-                from dagster._cli.utils import get_instance_for_cli
+            from dagster._cli.utils import get_instance_for_cli
 
-                # If arguments indicate it wants to load env vars, use the passed-in instance
-                # ref (or the dagster.yaml on the filesystem if no instance ref is provided)
+            instance_required = inject_env_vars_from_instance or defs_state_info is not None
+
+            try:
+                # we only require the instance if we need it to inject env vars or to load state,
+                # so in other cases we can swallow the error, but we should try to get it if possible
                 self._instance = self._exit_stack.enter_context(
                     get_instance_for_cli(instance_ref=instance_ref)
                 )
-
-                self._instance.inject_env_vars(location_name)
-            else:
+                if inject_env_vars_from_instance:
+                    self._instance.inject_env_vars(location_name)
+            except DagsterError as e:
+                if instance_required:
+                    raise e
                 self._instance = None
 
-            if defs_state_info is not None and self._instance is None:
-                instance_ref = check.not_none(
-                    self._instance_ref, "Cannot set defs_state_info without an instance_ref."
-                )
-                self._instance = self._exit_stack.enter_context(
-                    DagsterInstance.from_ref(instance_ref)
-                )
-
             self._loaded_repositories: Optional[LoadedRepositories] = LoadedRepositories(
                 loadable_target_origin,
                 entry_point=self._entry_point,

{dagster-1.11.15 → dagster-1.11.16}/dagster/_time/__init__.py

@@ -1,5 +1,7 @@
+import os
 import time
 from datetime import datetime, timedelta, timezone, tzinfo
+from functools import lru_cache
 from typing import Union, cast
 
 import dagster._check as check
@@ -178,7 +180,22 @@ def dst_safe_strftime(dt: datetime, tz: str, fmt: str, cron_schedule: str) -> st
     return dt.strftime(fmt)
 
 
+lru_cache_size = int(os.getenv("DAGSTER_DST_SAFE_STRPTIME_LRU_CACHE_SIZE", "0"))
+
+
 def dst_safe_strptime(date_string: str, tz: str, fmt: str) -> datetime:
+    if not lru_cache_size:
+        return _dst_safe_strptime_impl(date_string, tz, fmt)
+    else:
+        return _cached_dst_safe_strptime(date_string, tz, fmt)
+
+
+@lru_cache(maxsize=lru_cache_size)
+def _cached_dst_safe_strptime(date_string: str, tz: str, fmt: str) -> datetime:
+    return _dst_safe_strptime_impl(date_string, tz, fmt)
+
+
+def _dst_safe_strptime_impl(date_string: str, tz: str, fmt: str) -> datetime:
     """A method for parsing a datetime created with the dst_safe_strftime() method."""
     try:
         # first, try to parse the datetime in the normal format