dagster 1.11.15__tar.gz → 1.12.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dagster
-Version: 1.11.15
+Version: 1.12.0
 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.12.0
+Requires-Dist: dagster-shared==1.12.0
 Requires-Dist: antlr4-python3-runtime
 Provides-Extra: docker
 Requires-Dist: docker; extra == "docker"

{dagster-1.11.15 → dagster-1.12.0}/dagster/__init__.py

@@ -153,6 +153,7 @@ from dagster._core.definitions.asset_sensor_definition import (
 from dagster._core.definitions.assets.definition.asset_dep import AssetDep as AssetDep
 from dagster._core.definitions.assets.definition.asset_spec import (
     AssetSpec as AssetSpec,
+    apply_freshness_policy as apply_freshness_policy,
     map_asset_specs as map_asset_specs,
 )
 from dagster._core.definitions.assets.definition.assets_definition import (
@@ -256,6 +257,7 @@ from dagster._core.definitions.executor_definition import (
     multiple_process_executor_requirements as multiple_process_executor_requirements,
     multiprocess_executor as multiprocess_executor,
 )
+from dagster._core.definitions.freshness import FreshnessPolicy as FreshnessPolicy
 from dagster._core.definitions.freshness_policy import (
     LegacyFreshnessPolicy as LegacyFreshnessPolicy,
 )
@@ -346,6 +348,9 @@ from dagster._core.definitions.output import (
     Out as Out,
     OutputMapping as OutputMapping,
 )
+from dagster._core.definitions.partitions.context import (
+    partition_loading_context as partition_loading_context,
+)
 from dagster._core.definitions.partitions.definition import (
     DailyPartitionsDefinition as DailyPartitionsDefinition,
     DynamicPartitionsDefinition as DynamicPartitionsDefinition,
@@ -582,6 +587,7 @@ from dagster._core.storage.dagster_run import (
     RunRecord as RunRecord,
     RunsFilter as RunsFilter,
 )
+from dagster._core.storage.defs_state import UPathDefsStateStorage as UPathDefsStateStorage
 from dagster._core.storage.file_manager import (
     FileHandle as FileHandle,
     LocalFileHandle as LocalFileHandle,
@@ -656,6 +662,9 @@ from dagster.components.component.component import (
     ComponentTypeSpec as ComponentTypeSpec,
 )
 from dagster.components.component.component_loader import component_instance as component_instance
+from dagster.components.component.state_backed_component import (
+    StateBackedComponent as StateBackedComponent,
+)
 from dagster.components.component.template_vars import template_var as template_var
 from dagster.components.component_scaffolding import scaffold_component as scaffold_component
 from dagster.components.components import (
@@ -750,7 +759,6 @@ _DEPRECATED_RENAMED: Final[Mapping[str, tuple[Callable, str]]] = {
 _DEPRECATED_WITH_ERROR: Final[Mapping[str, str]] = {
     ##### EXAMPLE
     # "Foo": "Use Bar instead.",
-    "FreshnessPolicy": "FreshnessPolicy was renamed to LegacyFreshnessPolicy in 1.11.0. For more information, please refer to the section 'Migrating to 1.11.0' in the migration guide (MIGRATION.md)."
 }
 
 

dagster-1.12.0/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.12.0}/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.12.0}/dagster/_core/definitions/asset_checks/asset_check_factories/freshness_checks/last_update.py

@@ -3,7 +3,6 @@ from collections.abc import Iterable, Sequence
 from typing import Any, Optional, Union, cast
 
 from dagster import _check as check
-from dagster._annotations import beta
 from dagster._core.definitions.asset_checks.asset_check_factories.utils import (
     DEADLINE_CRON_PARAM_KEY,
     DEFAULT_FRESHNESS_SEVERITY,
@@ -36,6 +35,7 @@ from dagster._core.definitions.metadata import (
     TimestampMetadataValue,
 )
 from dagster._core.execution.context.compute import AssetCheckExecutionContext
+from dagster._symbol_annotations.lifecycle import superseded
 from dagster._time import get_current_timestamp, get_timezone
 from dagster._utils.schedules import (
     get_latest_completed_cron_tick,
@@ -44,7 +44,7 @@ from dagster._utils.schedules import (
 )
 
 
-@beta
+@superseded(additional_warn_text="Attach `FreshnessPolicy` objects to your assets instead.")
 def build_last_update_freshness_checks(
     *,
     assets: Sequence[Union[CoercibleToAssetKey, AssetsDefinition, SourceAsset]],

{dagster-1.11.15 → dagster-1.12.0}/dagster/_core/definitions/asset_checks/asset_check_factories/freshness_checks/sensor.py

@@ -3,7 +3,6 @@ from collections.abc import Iterator, Mapping, Sequence
 from typing import Any, Optional, Union, cast
 
 from dagster import _check as check
-from dagster._annotations import beta
 from dagster._core.definitions.asset_checks.asset_check_factories.utils import (
     FRESH_UNTIL_METADATA_KEY,
     ensure_no_duplicate_asset_checks,
@@ -21,6 +20,7 @@ from dagster._core.definitions.sensor_definition import (
 )
 from dagster._core.storage.asset_check_execution_record import AssetCheckExecutionRecordStatus
 from dagster._core.storage.tags import SENSOR_NAME_TAG
+from dagster._symbol_annotations.lifecycle import superseded
 from dagster._time import get_current_datetime, get_current_timestamp
 
 DEFAULT_FRESHNESS_SENSOR_NAME = "freshness_checks_sensor"
@@ -34,7 +34,9 @@ FRESHNESS_SENSOR_DESCRIPTION = """
     """
 
 
-@beta
+@superseded(
+    additional_warn_text="Use `FreshnessPolicy` objects, which do not require a sensor, instead."
+)
 def build_sensor_for_freshness_checks(
     *,
     freshness_checks: Sequence[AssetChecksDefinition],

{dagster-1.11.15 → dagster-1.12.0}/dagster/_core/definitions/asset_checks/asset_check_factories/freshness_checks/time_partition.py

@@ -2,7 +2,6 @@ from collections.abc import Iterable, Sequence
 from typing import Any, Union
 
 from dagster import _check as check
-from dagster._annotations import beta
 from dagster._core.definitions.asset_checks.asset_check_factories.utils import (
     DEADLINE_CRON_PARAM_KEY,
     DEFAULT_FRESHNESS_SEVERITY,
@@ -34,6 +33,7 @@ from dagster._core.definitions.metadata import (
 from dagster._core.definitions.partitions.context import partition_loading_context
 from dagster._core.definitions.partitions.definition import TimeWindowPartitionsDefinition
 from dagster._core.execution.context.compute import AssetCheckExecutionContext
+from dagster._symbol_annotations.lifecycle import superseded
 from dagster._time import datetime_from_timestamp, get_current_timestamp
 from dagster._utils.schedules import (
     get_latest_completed_cron_tick,
@@ -42,7 +42,7 @@ from dagster._utils.schedules import (
 )
 
 
-@beta
+@superseded(additional_warn_text="Attach `FreshnessPolicy` objects to your assets instead.")
 def build_time_partition_freshness_checks(
     *,
     assets: Sequence[Union[SourceAsset, CoercibleToAssetKey, AssetsDefinition]],

{dagster-1.11.15 → dagster-1.12.0}/dagster/_core/definitions/asset_daemon_cursor.py

@@ -69,7 +69,8 @@ class AssetDaemonCursor:
     """State that's stored between daemon evaluations.
 
     Args:
-        evaluation_id (int): The ID of the evaluation that produced this cursor.
+        evaluation_id (int): (DEPRECATED) The ID of the evaluation that produced this cursor.
+            This is no longer used as the source of truth for the evaluation id.
         previous_evaluation_state (Sequence[AutomationConditionEvaluationState]): (DEPRECATED) The
             evaluation info recorded for each asset on the previous tick.
         previous_cursors (Sequence[AutomationConditionCursor]): The cursor objects for each asset

{dagster-1.11.15 → dagster-1.12.0}/dagster/_core/definitions/assets/definition/asset_spec.py

@@ -27,7 +27,7 @@ from dagster._core.definitions.declarative_automation.automation_condition impor
     AutomationCondition,
 )
 from dagster._core.definitions.events import AssetKey, CoercibleToAssetKey
-from dagster._core.definitions.freshness import InternalFreshnessPolicy
+from dagster._core.definitions.freshness import FreshnessPolicy
 from dagster._core.definitions.freshness_policy import LegacyFreshnessPolicy
 from dagster._core.definitions.partitions.definition import PartitionsDefinition
 from dagster._core.definitions.partitions.mapping import PartitionMapping
@@ -155,7 +155,7 @@ class AssetSpec(IHasInternalInit, IHaveNew, LegacyNamedTupleMixin):
     skippable: PublicAttr[bool]
     code_version: PublicAttr[Optional[str]]
     legacy_freshness_policy: PublicAttr[Optional[LegacyFreshnessPolicy]]
-    freshness_policy: PublicAttr[Optional[InternalFreshnessPolicy]]
+    freshness_policy: PublicAttr[Optional[FreshnessPolicy]]
     automation_condition: PublicAttr[Optional[AutomationCondition]]
     owners: PublicAttr[Sequence[str]]
     tags: PublicAttr[Mapping[str, str]]
@@ -176,7 +176,7 @@ class AssetSpec(IHasInternalInit, IHaveNew, LegacyNamedTupleMixin):
         tags: Optional[Mapping[str, str]] = None,
         kinds: Optional[set[str]] = None,
         partitions_def: Optional[PartitionsDefinition] = None,
-        freshness_policy: Optional[InternalFreshnessPolicy] = None,
+        freshness_policy: Optional[FreshnessPolicy] = None,
         **kwargs,
     ):
         from dagster._core.definitions.assets.definition.asset_dep import (
@@ -216,7 +216,7 @@ class AssetSpec(IHasInternalInit, IHaveNew, LegacyNamedTupleMixin):
             freshness_policy=check.opt_inst_param(
                 freshness_policy,
                 "freshness_policy",
-                InternalFreshnessPolicy,
+                FreshnessPolicy,
                 additional_message="If you are using a LegacyFreshnessPolicy, pass this in with the `legacy_freshness_policy` parameter instead.",
             ),
             legacy_freshness_policy=check.opt_inst_param(
@@ -326,7 +326,7 @@ class AssetSpec(IHasInternalInit, IHaveNew, LegacyNamedTupleMixin):
         kinds: Optional[set[str]] = ...,
         partitions_def: Optional[PartitionsDefinition] = ...,
         legacy_freshness_policy: Optional[LegacyFreshnessPolicy] = ...,
-        freshness_policy: Optional[InternalFreshnessPolicy] = ...,
+        freshness_policy: Optional[FreshnessPolicy] = ...,
     ) -> "AssetSpec":
         """Returns a new AssetSpec with the specified attributes replaced."""
         current_tags_without_kinds = {
@@ -461,7 +461,7 @@ def map_asset_specs(
 
 @checked
 def apply_freshness_policy(
-    spec: AssetSpec, policy: InternalFreshnessPolicy, overwrite_existing=True
+    spec: AssetSpec, policy: FreshnessPolicy, overwrite_existing=True
 ) -> AssetSpec:
     """Apply a freshness policy to an asset spec.
 

{dagster-1.11.15 → dagster-1.12.0}/dagster/_core/definitions/assets/graph/asset_graph.py

@@ -22,7 +22,7 @@ from dagster._core.definitions.declarative_automation.automation_condition impor
     AutomationCondition,
 )
 from dagster._core.definitions.events import AssetKey
-from dagster._core.definitions.freshness import InternalFreshnessPolicy
+from dagster._core.definitions.freshness import FreshnessPolicy
 from dagster._core.definitions.freshness_policy import LegacyFreshnessPolicy
 from dagster._core.definitions.metadata import ArbitraryMetadataMapping
 from dagster._core.definitions.partitions.definition import PartitionsDefinition
@@ -117,7 +117,7 @@ class AssetNode(BaseAssetNode):
         return self._spec.legacy_freshness_policy
 
     @property
-    def freshness_policy(self) -> Optional[InternalFreshnessPolicy]:
+    def freshness_policy(self) -> Optional[FreshnessPolicy]:
         return self._spec.freshness_policy
 
     @property

{dagster-1.11.15 → dagster-1.12.0}/dagster/_core/definitions/assets/graph/base_asset_graph.py

@@ -20,7 +20,7 @@ from dagster._core.definitions.asset_checks.asset_check_spec import AssetCheckKe
 from dagster._core.definitions.asset_key import AssetKey, EntityKey, T_EntityKey
 from dagster._core.definitions.backfill_policy import BackfillPolicy
 from dagster._core.definitions.events import AssetKeyPartitionKey
-from dagster._core.definitions.freshness import InternalFreshnessPolicy
+from dagster._core.definitions.freshness import FreshnessPolicy
 from dagster._core.definitions.freshness_policy import LegacyFreshnessPolicy
 from dagster._core.definitions.metadata import ArbitraryMetadataMapping
 from dagster._core.definitions.partitions.definition import PartitionsDefinition
@@ -158,23 +158,21 @@ class BaseAssetNode(BaseEntityNode[AssetKey]):
 
     @property
     @abstractmethod
-    def freshness_policy(self) -> Optional[InternalFreshnessPolicy]:
+    def freshness_policy(self) -> Optional[FreshnessPolicy]:
         """WARNING: This field is not backwards compatible for policies created prior to 1.11.0.
         For backwards compatibility, use freshness_policy_or_from_metadata instead.
         """
         ...
 
     @property
-    def freshness_policy_or_from_metadata(self) -> Optional[InternalFreshnessPolicy]:
+    def freshness_policy_or_from_metadata(self) -> Optional[FreshnessPolicy]:
         """Prior to 1.11.0, freshness policy was stored in the node metadata. Freshness policy is a first-class attribute of the asset starting in 1.11.0.
 
         This field is backwards compatible since it checks for the policy in both the top-level attribute and the node metadata.
         """
-        from dagster._core.definitions.freshness import InternalFreshnessPolicy
+        from dagster._core.definitions.freshness import FreshnessPolicy
 
-        return self.freshness_policy or InternalFreshnessPolicy.from_asset_spec_metadata(
-            self.metadata
-        )
+        return self.freshness_policy or FreshnessPolicy.from_asset_spec_metadata(self.metadata)
 
     @property
     @abstractmethod

{dagster-1.11.15 → dagster-1.12.0}/dagster/_core/definitions/assets/graph/remote_asset_graph.py

@@ -35,7 +35,7 @@ from dagster._core.definitions.backfill_policy import BackfillPolicy
 from dagster._core.definitions.declarative_automation.automation_condition import (
     AutomationCondition,
 )
-from dagster._core.definitions.freshness import InternalFreshnessPolicy
+from dagster._core.definitions.freshness import FreshnessPolicy
 from dagster._core.definitions.freshness_policy import LegacyFreshnessPolicy
 from dagster._core.definitions.metadata import ArbitraryMetadataMapping
 from dagster._core.definitions.partitions.definition import PartitionsDefinition
@@ -123,7 +123,7 @@ class RemoteAssetNode(BaseAssetNode, ABC):
         return self.resolve_to_singular_repo_scoped_node().asset_node_snap.legacy_freshness_policy
 
     @property
-    def freshness_policy(self) -> Optional[InternalFreshnessPolicy]:
+    def freshness_policy(self) -> Optional[FreshnessPolicy]:
         return self.resolve_to_singular_repo_scoped_node().asset_node_snap.freshness_policy
 
     @property

{dagster-1.11.15 → dagster-1.12.0}/dagster/_core/definitions/assets/job/asset_out.py

@@ -2,12 +2,7 @@ from collections.abc import Mapping, Sequence
 from typing import Any, Optional, Union
 
 import dagster._check as check
-from dagster._annotations import (
-    deprecated_param,
-    hidden_param,
-    only_allow_hidden_params_in_kwargs,
-    public,
-)
+from dagster._annotations import hidden_param, only_allow_hidden_params_in_kwargs, public
 from dagster._core.definitions.assets.definition.asset_dep import AssetDep
 from dagster._core.definitions.assets.definition.asset_spec import AssetSpec
 from dagster._core.definitions.auto_materialize_policy import AutoMaterializePolicy
@@ -20,7 +15,7 @@ from dagster._core.definitions.events import (
     CoercibleToAssetKey,
     CoercibleToAssetKeyPrefix,
 )
-from dagster._core.definitions.freshness import InternalFreshnessPolicy
+from dagster._core.definitions.freshness import FreshnessPolicy
 from dagster._core.definitions.freshness_policy import LegacyFreshnessPolicy
 from dagster._core.definitions.input import NoValueSentinel
 from dagster._core.definitions.output import Out
@@ -37,7 +32,10 @@ from dagster._utils.warnings import disable_dagster_warnings
 EMPTY_ASSET_KEY_SENTINEL = AssetKey([])
 
 
-@deprecated_param(param="legacy_freshness_policy", breaking_version="1.12.0")
+@hidden_param(
+    param="legacy_freshness_policy",
+    breaking_version="1.13.0",
+)
 @hidden_param(
     param="auto_materialize_policy",
     breaking_version="1.10.0",
@@ -103,8 +101,7 @@ class AssetOut:
         owners: Optional[Sequence[str]] = None,
         tags: Optional[Mapping[str, str]] = None,
         kinds: Optional[set[str]] = None,
-        legacy_freshness_policy: Optional[LegacyFreshnessPolicy] = None,
-        freshness_policy: Optional[InternalFreshnessPolicy] = None,
+        freshness_policy: Optional[FreshnessPolicy] = None,
         **kwargs,
     ):
         # Accept a hidden "spec" argument to allow for the AssetOut to be constructed from an AssetSpec
@@ -122,6 +119,7 @@ class AssetOut:
         )
 
         auto_materialize_policy = kwargs.get("auto_materialize_policy")
+        legacy_freshness_policy = kwargs.get("legacy_freshness_policy")
         has_any_spec_args = any(
             [
                 key,
@@ -167,7 +165,7 @@ class AssetOut:
                 freshness_policy=check.opt_inst_param(
                     freshness_policy,
                     "freshness_policy",
-                    InternalFreshnessPolicy,
+                    FreshnessPolicy,
                 ),
                 owners=check.opt_sequence_param(owners, "owners", of_type=str),
                 tags=normalize_tags(tags or {}, strict=True),
@@ -204,7 +202,7 @@ class AssetOut:
         return self._spec.legacy_freshness_policy
 
     @property
-    def freshness_policy(self) -> Optional[InternalFreshnessPolicy]:
+    def freshness_policy(self) -> Optional[FreshnessPolicy]:
         return self._spec.freshness_policy
 
     @property

{dagster-1.11.15 → dagster-1.12.0}/dagster/_core/definitions/automation_tick_evaluation_context.py

@@ -71,6 +71,7 @@ class AutomationTickEvaluationContext:
             cursor=cursor,
             evaluation_time=evaluation_time,
             logger=logger,
+            evaluation_id=self._evaluation_id,
         )
         self._materialize_run_tags = materialize_run_tags
         self._observe_run_tags = observe_run_tags

{dagster-1.11.15 → dagster-1.12.0}/dagster/_core/definitions/declarative_automation/automation_condition_evaluator.py

@@ -34,6 +34,7 @@ class AutomationConditionEvaluator:
         asset_graph: BaseAssetGraph,
         cursor: AssetDaemonCursor,
         emit_backfills: bool,
+        evaluation_id: int,
         default_condition: Optional[AutomationCondition] = None,
         evaluation_time: Optional[datetime.datetime] = None,
         logger: logging.Logger = logging.getLogger("dagster.automation"),
@@ -68,6 +69,7 @@ class AutomationConditionEvaluator:
         self.legacy_data_time_resolver = CachingDataTimeResolver(self.instance_queryer)
 
         self.request_subsets_by_key: dict[EntityKey, EntitySubset] = {}
+        self.evaluation_id = evaluation_id
 
     @property
     def instance_queryer(self) -> "CachingInstanceQueryer":

{dagster-1.11.15 → dagster-1.12.0}/dagster/_core/definitions/declarative_automation/automation_condition_tester.py

@@ -147,6 +147,7 @@ def evaluate_automation_conditions(
         emit_backfills=False,
         logger=logging.getLogger("dagster.automation_condition_tester"),
         cursor=cursor,
+        evaluation_id=cursor.evaluation_id,
     )
     results, requested_subsets = evaluator.evaluate()
     with partition_loading_context(

{dagster-1.11.15 → dagster-1.12.0}/dagster/_core/definitions/declarative_automation/automation_context.py

@@ -49,6 +49,7 @@ def _has_legacy_condition(condition: AutomationCondition):
 
 @dataclass(frozen=True)
 class AutomationContext(Generic[T_EntityKey]):
+    evaluation_id: int
     condition: AutomationCondition
     condition_unique_ids: Sequence[str]
     candidate_subset: EntitySubset[T_EntityKey]
@@ -82,6 +83,7 @@ class AutomationContext(Generic[T_EntityKey]):
             asset_graph_view=asset_graph_view,
             request_subsets_by_key=evaluator.request_subsets_by_key,
             parent_context=None,
+            evaluation_id=evaluator.evaluation_id,
             _cursor=evaluator.cursor.get_previous_condition_cursor(key),
             _full_cursor=evaluator.cursor,
             _legacy_context=LegacyRuleEvaluationContext.create(key, evaluator)
@@ -109,6 +111,7 @@ class AutomationContext(Generic[T_EntityKey]):
             asset_graph_view=self.asset_graph_view,
             request_subsets_by_key=self.request_subsets_by_key,
             parent_context=self,
+            evaluation_id=self.evaluation_id,
             _cursor=self._cursor,
             _full_cursor=self._full_cursor,
             _legacy_context=self._legacy_context.for_child(
@@ -224,13 +227,6 @@ class AutomationContext(Generic[T_EntityKey]):
         """The `temporal_context` value used on the previous tick's evaluation."""
         return self._cursor.temporal_context if self._cursor else None
 
-    @property
-    def evaluation_id(self) -> int:
-        """Returns the current evaluation ID. This ID is incremented for each tick
-        and is global across all conditions.
-        """
-        return self._full_cursor.evaluation_id
-
     @property
     def legacy_context(self) -> LegacyRuleEvaluationContext:
         return check.not_none(

{dagster-1.11.15 → dagster-1.12.0}/dagster/_core/definitions/decorators/asset_decorator.py

@@ -43,7 +43,7 @@ from dagster._core.definitions.events import (
     CoercibleToAssetKey,
     CoercibleToAssetKeyPrefix,
 )
-from dagster._core.definitions.freshness import InternalFreshnessPolicy
+from dagster._core.definitions.freshness import FreshnessPolicy
 from dagster._core.definitions.freshness_policy import LegacyFreshnessPolicy
 from dagster._core.definitions.hook_definition import HookDefinition
 from dagster._core.definitions.input import GraphIn
@@ -173,7 +173,7 @@ def asset(
     group_name: Optional[str] = None,
     output_required: bool = True,
     automation_condition: Optional[AutomationCondition] = None,
-    freshness_policy: Optional[InternalFreshnessPolicy] = None,
+    freshness_policy: Optional[FreshnessPolicy] = None,
     backfill_policy: Optional[BackfillPolicy] = None,
     retry_policy: Optional[RetryPolicy] = None,
     code_version: Optional[str] = None,
@@ -411,7 +411,7 @@ class AssetDecoratorArgs(NamedTuple):
     group_name: Optional[str]
     output_required: bool
     legacy_freshness_policy: Optional[LegacyFreshnessPolicy]
-    freshness_policy: Optional[InternalFreshnessPolicy]
+    freshness_policy: Optional[FreshnessPolicy]
     automation_condition: Optional[AutomationCondition]
     backfill_policy: Optional[BackfillPolicy]
     retry_policy: Optional[RetryPolicy]

{dagster-1.11.15 → dagster-1.12.0}/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.
 
@@ -208,7 +208,7 @@ class DefinitionsLoadContext:
         key = config.key
         key_info = self._get_defs_key_state_info(key)
 
-        if config.type == DefsStateManagementType.LOCAL_FILESYSTEM:
+        if config.management_type == DefsStateManagementType.LOCAL_FILESYSTEM:
             # it is possible for local state to exist without the defs_state_storage being aware
             # of it if the state was added during docker build
             state_path = get_local_state_path(key, project_root)
@@ -217,10 +217,15 @@ class DefinitionsLoadContext:
                 return
             self.add_defs_state_info(key, LOCAL_STATE_VERSION, state_path.stat().st_ctime)
             yield state_path
-        elif config.type == DefsStateManagementType.VERSIONED_STATE_STORAGE:
+        elif config.management_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.management_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:
+            if key_info is None or key_info.management_type != config.management_type:
                 yield None
                 return
             # grab state for storage
@@ -228,7 +233,7 @@ class DefinitionsLoadContext:
                 state_path = Path(temp_dir) / "state"
                 state_storage.download_state_to_path(key, key_info.version, state_path)
                 yield state_path
-        elif config.type == DefsStateManagementType.LEGACY_CODE_SERVER_SNAPSHOTS:
+        elif config.management_type == DefsStateManagementType.LEGACY_CODE_SERVER_SNAPSHOTS:
             # state is stored in the reconstruction metadata
             with tempfile.TemporaryDirectory() as temp_dir:
                 state_path = Path(temp_dir) / "state"
@@ -236,7 +241,9 @@ class DefinitionsLoadContext:
                 state_path.write_text(state)
                 yield state_path
         else:
-            raise DagsterInvariantViolationError(f"Invalid management type: {config.type}")
+            raise DagsterInvariantViolationError(
+                f"Invalid management type: {config.management_type}"
+            )
 
 
 TState = TypeVar("TState", bound=PackableValue)