dagster 1.12.10__py3-none-any.whl → 1.12.11__py3-none-any.whl

dagster/_core/definitions/assets/graph/remote_asset_graph.py

@@ -520,7 +520,7 @@ class RemoteAssetGraph(BaseAssetGraph[TRemoteAssetNode], ABC, Generic[TRemoteAss
 
         by_table_name = defaultdict(set)
         for node in self.asset_nodes:
-            normalized_table_name = TableMetadataSet.extract(node.metadata).normalized_table_name
+            normalized_table_name = TableMetadataSet.extract_normalized_table_name(node.metadata)
             if normalized_table_name:
                 by_table_name[normalized_table_name.lower()].add(node.key)
 
@@ -547,7 +547,7 @@ class RemoteAssetGraph(BaseAssetGraph[TRemoteAssetNode], ABC, Generic[TRemoteAss
         from dagster._core.definitions.metadata.metadata_set import TableMetadataSet
 
         input_node = self.get(asset_key)
-        input_table_name = TableMetadataSet.extract(input_node.metadata).normalized_table_name
+        input_table_name = TableMetadataSet.extract_normalized_table_name(input_node.metadata)
 
         if not input_table_name:
             return set()

dagster/_core/definitions/inference.py

@@ -1,14 +1,16 @@
 from collections.abc import Callable, Mapping, Sequence
 from inspect import Parameter, Signature, isgeneratorfunction, signature
-from typing import Any, NamedTuple, Optional
+from typing import Any, Optional
 
+from dagster_shared.record import record
 from docstring_parser import parse
 
 from dagster._core.decorator_utils import get_type_hints
 from dagster._core.definitions.utils import NoValueSentinel
 
 
-class InferredInputProps(NamedTuple):
+@record
+class InferredInputProps:
     """The information about an input that can be inferred from the function signature."""
 
     name: str
@@ -17,7 +19,8 @@ class InferredInputProps(NamedTuple):
     default_value: Any = NoValueSentinel
 
 
-class InferredOutputProps(NamedTuple):
+@record
+class InferredOutputProps:
     """The information about an input that can be inferred from the function signature."""
 
     annotation: Any
@@ -80,15 +83,15 @@ def _infer_inputs_from_params(
     for param in params:
         if param.default is not Parameter.empty:
             input_def = InferredInputProps(
-                param.name,
-                type_hints.get(param.name, param.annotation),
+                name=param.name,
+                annotation=type_hints.get(param.name, param.annotation),
                 default_value=param.default,
                 description=_descriptions.get(param.name),
             )
         else:
             input_def = InferredInputProps(
-                param.name,
-                type_hints.get(param.name, param.annotation),
+                name=param.name,
+                annotation=type_hints.get(param.name, param.annotation),
                 description=_descriptions.get(param.name),
             )
 

dagster/_core/definitions/input.py

@@ -1,12 +1,13 @@
 import inspect
 from collections.abc import Callable, Mapping
-from types import FunctionType, UnionType
-from typing import TYPE_CHECKING, Any, NamedTuple, Optional, TypeVar, Union
+from types import UnionType
+from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
 
 from dagster_shared.error import DagsterError
+from dagster_shared.record import IHaveNew, record, record_custom
 
 import dagster._check as check
-from dagster._annotations import PublicAttr, deprecated_param, public, superseded
+from dagster._annotations import PublicAttr, public, superseded
 from dagster._core.definitions.events import AssetKey
 from dagster._core.definitions.inference import InferredInputProps
 from dagster._core.definitions.metadata import (
@@ -309,39 +310,22 @@ def _checked_inferred_type(inferred: InferredInputProps) -> DagsterType:
     return resolved_type
 
 
-class InputPointer(NamedTuple("_InputPointer", [("node_name", str), ("input_name", str)])):
-    def __new__(cls, node_name: str, input_name: str):
-        return super().__new__(
-            cls,
-            check.str_param(node_name, "node_name"),
-            check.str_param(input_name, "input_name"),
-        )
+@record(kw_only=False)
+class InputPointer:
+    node_name: str
+    input_name: str
 
 
-class FanInInputPointer(
-    NamedTuple(
-        "_FanInInputPointer", [("node_name", str), ("input_name", str), ("fan_in_index", int)]
-    )
-):
-    def __new__(cls, node_name: str, input_name: str, fan_in_index: int):
-        return super().__new__(
-            cls,
-            check.str_param(node_name, "node_name"),
-            check.str_param(input_name, "input_name"),
-            check.int_param(fan_in_index, "fan_in_index"),
-        )
+@record(kw_only=False)
+class FanInInputPointer:
+    node_name: str
+    input_name: str
+    fan_in_index: int
 
 
-@deprecated_param(
-    param="dagster_type",
-    breaking_version="2.0",
-    additional_warn_text="Any defined `dagster_type` should come from the upstream op `Output`.",
-    # Disabling warning here since we're passing this internally and I'm not sure whether it is
-    # actually used or discarded.
-    emit_runtime_warning=False,
-)
 @public
-class InputMapping(NamedTuple):
+@record
+class InputMapping:
     """Defines an input mapping for a graph.
 
     Args:
@@ -350,8 +334,8 @@ class InputMapping(NamedTuple):
         mapped_node_input_name (str): Name of the input in the node (op/graph) that is being mapped to.
         fan_in_index (Optional[int]): The index in to a fanned input, otherwise None.
         graph_input_description (Optional[str]): A description of the input in the graph being mapped from.
-        dagster_type (Optional[DagsterType]): The dagster type of the graph's input
-            being mapped from.
+        dagster_type (Optional[DagsterType]): DEPRECATED, to be removed in 2.0.
+            The dagster type of the graph's input being mapped from.
 
     Examples:
         .. code-block:: python
@@ -384,6 +368,8 @@ class InputMapping(NamedTuple):
     mapped_node_input_name: str
     fan_in_index: Optional[int] = None
     graph_input_description: Optional[str] = None
+
+    # DEPRECATED: Any defined `dagster_type` should come from the upstream op `Output`.
     dagster_type: Optional[DagsterType] = None
 
     @property
@@ -411,26 +397,8 @@ class InputMapping(NamedTuple):
 
 
 @public
-class In(
-    NamedTuple(
-        "_In",
-        [
-            ("dagster_type", PublicAttr[Union[DagsterType, type[NoValueSentinel]]]),
-            ("description", PublicAttr[Optional[str]]),
-            ("default_value", PublicAttr[Any]),
-            ("metadata", PublicAttr[Optional[Mapping[str, Any]]]),
-            (
-                "asset_key",
-                PublicAttr[Optional[Union[AssetKey, Callable[["InputContext"], AssetKey]]]],
-            ),
-            (
-                "asset_partitions",
-                PublicAttr[Optional[Union[set[str], Callable[["InputContext"], set[str]]]]],
-            ),
-            ("input_manager_key", PublicAttr[Optional[str]]),
-        ],
-    )
-):
+@record_custom
+class In(IHaveNew):
     """Defines an argument to an op's compute function.
 
     Inputs may flow from previous op's outputs, or be stubbed using config. They may optionally
@@ -454,6 +422,14 @@ class In(
             upstream output.
     """
 
+    dagster_type: PublicAttr[Union[DagsterType, type[NoValueSentinel]]]
+    description: PublicAttr[Optional[str]]
+    default_value: PublicAttr[Any]
+    metadata: PublicAttr[Mapping[str, Any]]
+    asset_key: PublicAttr[Optional[Union[AssetKey, Callable[["InputContext"], AssetKey]]]]
+    asset_partitions: PublicAttr[Optional[Union[set[str], Callable[["InputContext"], set[str]]]]]
+    input_manager_key: PublicAttr[Optional[str]]
+
     def __new__(
         cls,
         dagster_type: Union[type, UnionType, DagsterType] = NoValueSentinel,
@@ -471,12 +447,12 @@ class In(
                 if dagster_type is NoValueSentinel
                 else resolve_dagster_type(dagster_type)
             ),
-            description=check.opt_str_param(description, "description"),
+            description=description,
             default_value=default_value,
-            metadata=check.opt_mapping_param(metadata, "metadata", key_type=str),
-            asset_key=check.opt_inst_param(asset_key, "asset_key", (AssetKey, FunctionType)),
+            metadata={} if metadata is None else metadata,
+            asset_key=asset_key,
             asset_partitions=asset_partitions,
-            input_manager_key=check.opt_str_param(input_manager_key, "input_manager_key"),
+            input_manager_key=input_manager_key,
         )
 
     @staticmethod
@@ -506,15 +482,15 @@ class In(
 
 
 @public
-class GraphIn(NamedTuple("_GraphIn", [("description", PublicAttr[Optional[str]])])):
+@record
+class GraphIn:
     """Represents information about an input that a graph maps.
 
     Args:
         description (Optional[str]): Human-readable description of the input.
     """
 
-    def __new__(cls, description: Optional[str] = None):
-        return super().__new__(cls, description=description)
+    description: PublicAttr[Optional[str]] = None
 
     def to_definition(self, name: str) -> InputDefinition:
         return InputDefinition(name=name, description=self.description)

dagster/_core/definitions/metadata/metadata_set.py

@@ -197,9 +197,20 @@ class TableMetadataSet(NamespacedMetadataSet):
     def current_key_by_legacy_key(cls) -> Mapping[str, str]:
         return {"relation_identifier": "table_name"}
 
-    @property
-    def normalized_table_name(self) -> Optional[str]:
-        return self.table_name.lower() if self.table_name else None
+    @classmethod
+    def extract_normalized_table_name(cls, metadata: Mapping[str, Any]) -> Optional[str]:
+        from pydantic import ValidationError
+
+        metadata_subset = {
+            key: metadata[key]
+            for key in {"dagster/table_name", "dagster/relation_identifier"}
+            if key in metadata
+        }
+        try:
+            table_name = TableMetadataSet.extract(metadata_subset).table_name
+            return table_name.lower() if table_name else None
+        except ValidationError:
+            return None
 
 
 class UriMetadataSet(NamespacedMetadataSet):

dagster/_grpc/types.py

@@ -1,8 +1,9 @@
 import base64
 import zlib
 from collections.abc import Mapping, Sequence
-from typing import AbstractSet, Any, NamedTuple, Optional  # noqa: UP035
+from typing import AbstractSet, Any, Optional  # noqa: UP035
 
+from dagster_shared.record import IHaveNew, copy, record, record_custom
 from dagster_shared.serdes.objects.models.defs_state_info import DefsStateInfo
 from dagster_shared.serdes.serdes import SetToSequenceFieldSerializer
 
@@ -30,55 +31,18 @@ from dagster._utils.error import SerializableErrorInfo
         "op_selection": "solid_selection",
     }
 )
-class ExecutionPlanSnapshotArgs(
-    NamedTuple(
-        "_ExecutionPlanSnapshotArgs",
-        [
-            ("job_origin", RemoteJobOrigin),
-            ("op_selection", Sequence[str]),
-            ("run_config", Mapping[str, object]),
-            ("step_keys_to_execute", Optional[Sequence[str]]),
-            ("job_snapshot_id", str),
-            ("known_state", Optional[KnownExecutionState]),
-            ("instance_ref", Optional[InstanceRef]),
-            ("asset_selection", Optional[AbstractSet[AssetKey]]),
-            ("asset_check_selection", Optional[AbstractSet[AssetCheckKey]]),
-            ("mode", str),
-        ],
-    )
-):
-    def __new__(
-        cls,
-        job_origin: RemoteJobOrigin,
-        op_selection: Sequence[str],
-        run_config: Mapping[str, object],
-        step_keys_to_execute: Optional[Sequence[str]],
-        job_snapshot_id: str,
-        known_state: Optional[KnownExecutionState] = None,
-        instance_ref: Optional[InstanceRef] = None,
-        asset_selection: Optional[AbstractSet[AssetKey]] = None,
-        asset_check_selection: Optional[AbstractSet[AssetCheckKey]] = None,
-        mode: str = DEFAULT_MODE_NAME,
-    ):
-        return super().__new__(
-            cls,
-            job_origin=check.inst_param(job_origin, "job_origin", RemoteJobOrigin),
-            op_selection=check.opt_sequence_param(op_selection, "op_selection", of_type=str),
-            run_config=check.mapping_param(run_config, "run_config", key_type=str),
-            mode=check.str_param(mode, "mode"),
-            step_keys_to_execute=check.opt_nullable_sequence_param(
-                step_keys_to_execute, "step_keys_to_execute", of_type=str
-            ),
-            job_snapshot_id=check.str_param(job_snapshot_id, "job_snapshot_id"),
-            known_state=check.opt_inst_param(known_state, "known_state", KnownExecutionState),
-            instance_ref=check.opt_inst_param(instance_ref, "instance_ref", InstanceRef),
-            asset_selection=check.opt_nullable_set_param(
-                asset_selection, "asset_selection", of_type=AssetKey
-            ),
-            asset_check_selection=check.opt_nullable_set_param(
-                asset_check_selection, "asset_check_selection", of_type=AssetCheckKey
-            ),
-        )
+@record
+class ExecutionPlanSnapshotArgs:
+    job_origin: RemoteJobOrigin
+    op_selection: Sequence[str]
+    run_config: Mapping[str, object]
+    step_keys_to_execute: Optional[Sequence[str]]
+    job_snapshot_id: str
+    known_state: Optional[KnownExecutionState] = None
+    instance_ref: Optional[InstanceRef] = None
+    asset_selection: Optional[AbstractSet[AssetKey]] = None
+    asset_check_selection: Optional[AbstractSet[AssetCheckKey]] = None
+    mode: str = DEFAULT_MODE_NAME
 
 
 def _get_entry_point(origin: JobPythonOrigin):
@@ -95,18 +59,14 @@ def _get_entry_point(origin: JobPythonOrigin):
         "run_id": "pipeline_run_id",
     }
 )
-class ExecuteRunArgs(
-    NamedTuple(
-        "_ExecuteRunArgs",
-        [
-            # Deprecated, only needed for back-compat since it can be pulled from the PipelineRun
-            ("job_origin", JobPythonOrigin),
-            ("run_id", str),
-            ("instance_ref", Optional[InstanceRef]),
-            ("set_exit_code_on_failure", Optional[bool]),
-        ],
-    )
-):
+@record_custom
+class ExecuteRunArgs(IHaveNew):
+    # Deprecated, only needed for back-compat since it can be pulled from the PipelineRun
+    job_origin: JobPythonOrigin
+    run_id: str
+    instance_ref: Optional[InstanceRef]
+    set_exit_code_on_failure: Optional[bool]
+
     def __new__(
         cls,
         job_origin: JobPythonOrigin,
@@ -116,19 +76,11 @@ class ExecuteRunArgs(
     ):
         return super().__new__(
             cls,
-            job_origin=check.inst_param(
-                job_origin,
-                "job_origin",
-                JobPythonOrigin,
-            ),
-            run_id=check.str_param(run_id, "run_id"),
-            instance_ref=check.opt_inst_param(instance_ref, "instance_ref", InstanceRef),
-            set_exit_code_on_failure=(
-                True
-                if check.opt_bool_param(set_exit_code_on_failure, "set_exit_code_on_failure")
-                is True
-                else None
-            ),  # for back-compat
+            job_origin=job_origin,
+            run_id=run_id,
+            instance_ref=instance_ref,
+            # for back-compat: only True or None allowed
+            set_exit_code_on_failure=True if set_exit_code_on_failure is True else None,
         )
 
     def get_command_args(self) -> Sequence[str]:
@@ -146,18 +98,14 @@ class ExecuteRunArgs(
         "run_id": "pipeline_run_id",
     }
 )
-class ResumeRunArgs(
-    NamedTuple(
-        "_ResumeRunArgs",
-        [
-            # Deprecated, only needed for back-compat since it can be pulled from the DagsterRun
-            ("job_origin", JobPythonOrigin),
-            ("run_id", str),
-            ("instance_ref", Optional[InstanceRef]),
-            ("set_exit_code_on_failure", Optional[bool]),
-        ],
-    )
-):
+@record_custom
+class ResumeRunArgs(IHaveNew):
+    # Deprecated, only needed for back-compat since it can be pulled from the DagsterRun
+    job_origin: JobPythonOrigin
+    run_id: str
+    instance_ref: Optional[InstanceRef]
+    set_exit_code_on_failure: Optional[bool]
+
     def __new__(
         cls,
         job_origin: JobPythonOrigin,
@@ -167,19 +115,11 @@ class ResumeRunArgs(
     ):
         return super().__new__(
             cls,
-            job_origin=check.inst_param(
-                job_origin,
-                "job_origin",
-                JobPythonOrigin,
-            ),
-            run_id=check.str_param(run_id, "run_id"),
-            instance_ref=check.opt_inst_param(instance_ref, "instance_ref", InstanceRef),
-            set_exit_code_on_failure=(
-                True
-                if check.opt_bool_param(set_exit_code_on_failure, "set_exit_code_on_failure")
-                is True
-                else None
-            ),  # for back-compat
+            job_origin=job_origin,
+            run_id=run_id,
+            instance_ref=instance_ref,
+            # for back-compat: only True or None allowed
+            set_exit_code_on_failure=True if set_exit_code_on_failure is True else None,
         )
 
     def get_command_args(self) -> Sequence[str]:
@@ -198,32 +138,11 @@ class ResumeRunArgs(
         "run_id": "pipeline_run_id",
     },
 )
-class ExecuteExternalJobArgs(
-    NamedTuple(
-        "_ExecuteExternalJobArgs",
-        [
-            ("job_origin", RemoteJobOrigin),
-            ("run_id", str),
-            ("instance_ref", Optional[InstanceRef]),
-        ],
-    )
-):
-    def __new__(
-        cls,
-        job_origin: RemoteJobOrigin,
-        run_id: str,
-        instance_ref: Optional[InstanceRef],
-    ):
-        return super().__new__(
-            cls,
-            job_origin=check.inst_param(
-                job_origin,
-                "job_origin",
-                RemoteJobOrigin,
-            ),
-            run_id=check.str_param(run_id, "run_id"),
-            instance_ref=check.opt_inst_param(instance_ref, "instance_ref", InstanceRef),
-        )
+@record
+class ExecuteExternalJobArgs:
+    job_origin: RemoteJobOrigin
+    run_id: str
+    instance_ref: Optional[InstanceRef]
 
 
 @whitelist_for_serdes(
@@ -232,22 +151,18 @@ class ExecuteExternalJobArgs(
         "run_id": "pipeline_run_id",
     }
 )
-class ExecuteStepArgs(
-    NamedTuple(
-        "_ExecuteStepArgs",
-        [
-            # Deprecated, only needed for back-compat since it can be pulled from the DagsterRun
-            ("job_origin", JobPythonOrigin),
-            ("run_id", str),
-            ("step_keys_to_execute", Optional[Sequence[str]]),
-            ("instance_ref", Optional[InstanceRef]),
-            ("retry_mode", Optional[RetryMode]),
-            ("known_state", Optional[KnownExecutionState]),
-            ("should_verify_step", Optional[bool]),
-            ("print_serialized_events", bool),
-        ],
-    )
-):
+@record_custom
+class ExecuteStepArgs(IHaveNew):
+    # Deprecated, only needed for back-compat since it can be pulled from the DagsterRun
+    job_origin: JobPythonOrigin
+    run_id: str
+    step_keys_to_execute: Optional[Sequence[str]]
+    instance_ref: Optional[InstanceRef]
+    retry_mode: Optional[RetryMode]
+    known_state: Optional[KnownExecutionState]
+    should_verify_step: Optional[bool]
+    print_serialized_events: bool
+
     def __new__(
         cls,
         job_origin: JobPythonOrigin,
@@ -261,19 +176,15 @@ class ExecuteStepArgs(
     ):
         return super().__new__(
             cls,
-            job_origin=check.inst_param(job_origin, "job_origin", JobPythonOrigin),
-            run_id=check.str_param(run_id, "run_id"),
-            step_keys_to_execute=check.opt_nullable_sequence_param(
-                step_keys_to_execute, "step_keys_to_execute", of_type=str
-            ),
-            instance_ref=check.opt_inst_param(instance_ref, "instance_ref", InstanceRef),
-            retry_mode=check.opt_inst_param(retry_mode, "retry_mode", RetryMode),
-            known_state=check.opt_inst_param(known_state, "known_state", KnownExecutionState),
-            should_verify_step=check.opt_bool_param(
-                should_verify_step, "should_verify_step", False
-            ),
-            print_serialized_events=check.opt_bool_param(
-                print_serialized_events, "print_serialized_events", False
+            job_origin=job_origin,
+            run_id=run_id,
+            step_keys_to_execute=step_keys_to_execute,
+            instance_ref=instance_ref,
+            retry_mode=retry_mode,
+            known_state=known_state,
+            should_verify_step=should_verify_step if should_verify_step is not None else False,
+            print_serialized_events=(
+                print_serialized_events if print_serialized_events is not None else False
             ),
         )
 
@@ -306,33 +217,24 @@ class ExecuteStepArgs(
 
 
 @whitelist_for_serdes
-class LoadableRepositorySymbol(
-    NamedTuple("_LoadableRepositorySymbol", [("repository_name", str), ("attribute", str)])
-):
-    def __new__(cls, repository_name: str, attribute: str):
-        return super().__new__(
-            cls,
-            repository_name=check.str_param(repository_name, "repository_name"),
-            attribute=check.str_param(attribute, "attribute"),
-        )
+@record
+class LoadableRepositorySymbol:
+    repository_name: str
+    attribute: str
 
 
 @whitelist_for_serdes
-class ListRepositoriesResponse(
-    NamedTuple(
-        "_ListRepositoriesResponse",
-        [
-            ("repository_symbols", Sequence[LoadableRepositorySymbol]),
-            ("executable_path", Optional[str]),
-            ("repository_code_pointer_dict", Mapping[str, CodePointer]),
-            ("entry_point", Optional[Sequence[str]]),
-            ("container_image", Optional[str]),
-            ("container_context", Optional[Mapping[str, Any]]),
-            ("dagster_library_versions", Optional[Mapping[str, str]]),
-            ("defs_state_info", Optional[DefsStateInfo]),
-        ],
-    )
-):
+@record_custom
+class ListRepositoriesResponse(IHaveNew):
+    repository_symbols: Sequence[LoadableRepositorySymbol]
+    executable_path: Optional[str]
+    repository_code_pointer_dict: Mapping[str, CodePointer]
+    entry_point: Optional[Sequence[str]]
+    container_image: Optional[str]
+    container_context: Optional[Mapping[str, Any]]
+    dagster_library_versions: Optional[Mapping[str, str]]
+    defs_state_info: Optional[DefsStateInfo]
+
     def __new__(
         cls,
         repository_symbols: Sequence[LoadableRepositorySymbol],
@@ -340,52 +242,33 @@ class ListRepositoriesResponse(
         repository_code_pointer_dict: Optional[Mapping[str, CodePointer]] = None,
         entry_point: Optional[Sequence[str]] = None,
         container_image: Optional[str] = None,
-        container_context: Optional[Mapping] = None,
+        container_context: Optional[Mapping[str, Any]] = None,
         dagster_library_versions: Optional[Mapping[str, str]] = None,
         defs_state_info: Optional[DefsStateInfo] = None,
     ):
         return super().__new__(
             cls,
-            repository_symbols=check.sequence_param(
-                repository_symbols, "repository_symbols", of_type=LoadableRepositorySymbol
-            ),
-            executable_path=check.opt_str_param(executable_path, "executable_path"),
-            repository_code_pointer_dict=check.opt_mapping_param(
-                repository_code_pointer_dict,
-                "repository_code_pointer_dict",
-                key_type=str,
-                value_type=CodePointer,
-            ),
-            entry_point=(
-                check.sequence_param(entry_point, "entry_point", of_type=str)
-                if entry_point is not None
-                else None
-            ),
-            container_image=check.opt_str_param(container_image, "container_image"),
-            container_context=(
-                check.dict_param(container_context, "container_context")
-                if container_context is not None
-                else None
-            ),
-            dagster_library_versions=check.opt_nullable_mapping_param(
-                dagster_library_versions, "dagster_library_versions"
-            ),
-            defs_state_info=check.opt_inst_param(defs_state_info, "defs_state_info", DefsStateInfo),
+            repository_symbols=repository_symbols,
+            executable_path=executable_path,
+            repository_code_pointer_dict=(
+                repository_code_pointer_dict if repository_code_pointer_dict is not None else {}
+            ),
+            entry_point=entry_point,
+            container_image=container_image,
+            container_context=container_context,
+            dagster_library_versions=dagster_library_versions,
+            defs_state_info=defs_state_info,
         )
 
 
 @whitelist_for_serdes
-class ListRepositoriesInput(
-    NamedTuple(
-        "_ListRepositoriesInput",
-        [
-            ("module_name", Optional[str]),
-            ("python_file", Optional[str]),
-            ("working_directory", Optional[str]),
-            ("attribute", Optional[str]),
-        ],
-    )
-):
+@record_custom
+class ListRepositoriesInput(IHaveNew):
+    module_name: Optional[str]
+    python_file: Optional[str]
+    working_directory: Optional[str]
+    attribute: Optional[str]
+
     def __new__(
         cls,
         module_name: Optional[str],
@@ -397,47 +280,22 @@ class ListRepositoriesInput(
         check.invariant(module_name or python_file, "Must set at least one")
         return super().__new__(
             cls,
-            module_name=check.opt_str_param(module_name, "module_name"),
-            python_file=check.opt_str_param(python_file, "python_file"),
-            working_directory=check.opt_str_param(working_directory, "working_directory"),
-            attribute=check.opt_str_param(attribute, "attribute"),
+            module_name=module_name,
+            python_file=python_file,
+            working_directory=working_directory,
+            attribute=attribute,
         )
 
 
 @whitelist_for_serdes
-class PartitionArgs(
-    NamedTuple(
-        "_PartitionArgs",
-        [
-            ("repository_origin", RemoteRepositoryOrigin),
-            # This is here for backcompat. it's expected to always be f"{job_name}_partition_set".
-            ("partition_set_name", str),
-            ("partition_name", str),
-            ("job_name", Optional[str]),
-            ("instance_ref", Optional[InstanceRef]),
-        ],
-    )
-):
-    def __new__(
-        cls,
-        repository_origin: RemoteRepositoryOrigin,
-        partition_set_name: str,
-        partition_name: str,
-        job_name: Optional[str] = None,
-        instance_ref: Optional[InstanceRef] = None,
-    ):
-        return super().__new__(
-            cls,
-            repository_origin=check.inst_param(
-                repository_origin,
-                "repository_origin",
-                RemoteRepositoryOrigin,
-            ),
-            partition_set_name=check.str_param(partition_set_name, "partition_set_name"),
-            job_name=check.opt_str_param(job_name, "job_name"),
-            partition_name=check.str_param(partition_name, "partition_name"),
-            instance_ref=check.opt_inst_param(instance_ref, "instance_ref", InstanceRef),
-        )
+@record
+class PartitionArgs:
+    repository_origin: RemoteRepositoryOrigin
+    # This is here for backcompat. it's expected to always be f"{job_name}_partition_set".
+    partition_set_name: str
+    partition_name: str
+    job_name: Optional[str] = None
+    instance_ref: Optional[InstanceRef] = None
 
     def get_job_name(self) -> str:
         if self.job_name:
@@ -447,35 +305,16 @@ class PartitionArgs(
 
 
 @whitelist_for_serdes
-class PartitionNamesArgs(
-    NamedTuple(
-        "_PartitionNamesArgs",
-        [
-            ("repository_origin", RemoteRepositoryOrigin),
-            # This is here for backcompat. it's expected to always be f"{job_name}_partition_set".
-            ("partition_set_name", str),
-            # This is introduced in the same release that we're making it possible for an asset job
-            # to target assets with different PartitionsDefinitions. Prior user code versions can
-            # (and do) safely ignore this parameter, because, in those versions, the job name on its
-            # own is enough to specify which PartitionsDefinition to use.
-            ("job_name", Optional[str]),
-        ],
-    )
-):
-    def __new__(
-        cls,
-        repository_origin: RemoteRepositoryOrigin,
-        partition_set_name: str,
-        job_name: Optional[str] = None,
-    ):
-        return super().__new__(
-            cls,
-            repository_origin=check.inst_param(
-                repository_origin, "repository_origin", RemoteRepositoryOrigin
-            ),
-            job_name=check.opt_str_param(job_name, "job_name"),
-            partition_set_name=check.str_param(partition_set_name, "partition_set_name"),
-        )
+@record
+class PartitionNamesArgs:
+    repository_origin: RemoteRepositoryOrigin
+    # This is here for backcompat. it's expected to always be f"{job_name}_partition_set".
+    partition_set_name: str
+    # This is introduced in the same release that we're making it possible for an asset job
+    # to target assets with different PartitionsDefinitions. Prior user code versions can
+    # (and do) safely ignore this parameter, because, in those versions, the job name on its
+    # own is enough to specify which PartitionsDefinition to use.
+    job_name: Optional[str] = None
 
     def get_job_name(self) -> str:
         if self.job_name:
@@ -485,33 +324,12 @@ class PartitionNamesArgs(
 
 
 @whitelist_for_serdes
-class PartitionSetExecutionParamArgs(
-    NamedTuple(
-        "_PartitionSetExecutionParamArgs",
-        [
-            ("repository_origin", RemoteRepositoryOrigin),
-            ("partition_set_name", str),
-            ("partition_names", Sequence[str]),
-            ("instance_ref", Optional[InstanceRef]),
-        ],
-    )
-):
-    def __new__(
-        cls,
-        repository_origin: RemoteRepositoryOrigin,
-        partition_set_name: str,
-        partition_names: Sequence[str],
-        instance_ref: Optional[InstanceRef] = None,
-    ):
-        return super().__new__(
-            cls,
-            repository_origin=check.inst_param(
-                repository_origin, "repository_origin", RemoteRepositoryOrigin
-            ),
-            partition_set_name=check.str_param(partition_set_name, "partition_set_name"),
-            partition_names=check.sequence_param(partition_names, "partition_names", of_type=str),
-            instance_ref=check.opt_inst_param(instance_ref, "instance_ref", InstanceRef),
-        )
+@record
+class PartitionSetExecutionParamArgs:
+    repository_origin: RemoteRepositoryOrigin
+    partition_set_name: str
+    partition_names: Sequence[str]
+    instance_ref: Optional[InstanceRef] = None
 
 
 @whitelist_for_serdes(
@@ -523,18 +341,14 @@ class PartitionSetExecutionParamArgs(
     # asset_selection previously was erroneously represented as a sequence
     field_serializers={"asset_selection": SetToSequenceFieldSerializer},
 )
-class JobSubsetSnapshotArgs(
-    NamedTuple(
-        "_JobSubsetSnapshotArgs",
-        [
-            ("job_origin", RemoteJobOrigin),
-            ("op_selection", Optional[Sequence[str]]),
-            ("asset_selection", Optional[AbstractSet[AssetKey]]),
-            ("asset_check_selection", Optional[AbstractSet[AssetCheckKey]]),
-            ("include_parent_snapshot", bool),
-        ],
-    )
-):
+@record_custom
+class JobSubsetSnapshotArgs(IHaveNew):
+    job_origin: RemoteJobOrigin
+    op_selection: Optional[Sequence[str]]
+    asset_selection: Optional[AbstractSet[AssetKey]]
+    asset_check_selection: Optional[AbstractSet[AssetCheckKey]]
+    include_parent_snapshot: bool
+
     def __new__(
         cls,
         job_origin: RemoteJobOrigin,
@@ -545,14 +359,10 @@ class JobSubsetSnapshotArgs(
     ):
         return super().__new__(
             cls,
-            job_origin=check.inst_param(job_origin, "job_origin", RemoteJobOrigin),
-            op_selection=check.opt_nullable_sequence_param(
-                op_selection, "op_selection", of_type=str
-            ),
-            asset_selection=check.opt_nullable_set_param(asset_selection, "asset_selection"),
-            asset_check_selection=check.opt_nullable_set_param(
-                asset_check_selection, "asset_check_selection"
-            ),
+            job_origin=job_origin,
+            op_selection=op_selection,
+            asset_selection=asset_selection,
+            asset_check_selection=asset_check_selection,
             include_parent_snapshot=(
                 include_parent_snapshot if include_parent_snapshot is not None else True
             ),
@@ -561,37 +371,23 @@ class JobSubsetSnapshotArgs(
 
 # Different storage field name for backcompat
 @whitelist_for_serdes(storage_field_names={"code_location_origin": "repository_location_origin"})
-class NotebookPathArgs(
-    NamedTuple(
-        "_NotebookPathArgs",
-        [("code_location_origin", CodeLocationOrigin), ("notebook_path", str)],
-    )
-):
-    def __new__(cls, code_location_origin: CodeLocationOrigin, notebook_path: str):
-        return super().__new__(
-            cls,
-            code_location_origin=check.inst_param(
-                code_location_origin, "code_location_origin", CodeLocationOrigin
-            ),
-            notebook_path=check.str_param(notebook_path, "notebook_path"),
-        )
+@record
+class NotebookPathArgs:
+    code_location_origin: CodeLocationOrigin
+    notebook_path: str
 
 
 @whitelist_for_serdes
-class ExternalScheduleExecutionArgs(
-    NamedTuple(
-        "_ExternalScheduleExecutionArgs",
-        [
-            ("repository_origin", RemoteRepositoryOrigin),
-            ("instance_ref", Optional[InstanceRef]),
-            ("schedule_name", str),
-            ("scheduled_execution_timestamp", Optional[float]),
-            ("scheduled_execution_timezone", Optional[str]),
-            ("log_key", Optional[Sequence[str]]),
-            ("timeout", Optional[int]),
-        ],
-    )
-):
+@record_custom
+class ExternalScheduleExecutionArgs(IHaveNew):
+    repository_origin: RemoteRepositoryOrigin
+    instance_ref: Optional[InstanceRef]
+    schedule_name: str
+    scheduled_execution_timestamp: Optional[float]
+    scheduled_execution_timezone: Optional[str]
+    log_key: Sequence[str]
+    timeout: Optional[int]
+
     def __new__(
         cls,
         repository_origin: RemoteRepositoryOrigin,
@@ -604,42 +400,31 @@ class ExternalScheduleExecutionArgs(
     ):
         return super().__new__(
             cls,
-            repository_origin=check.inst_param(
-                repository_origin, "repository_origin", RemoteRepositoryOrigin
-            ),
-            instance_ref=check.opt_inst_param(instance_ref, "instance_ref", InstanceRef),
-            schedule_name=check.str_param(schedule_name, "schedule_name"),
-            scheduled_execution_timestamp=check.opt_float_param(
-                scheduled_execution_timestamp, "scheduled_execution_timestamp"
-            ),
-            scheduled_execution_timezone=check.opt_str_param(
-                scheduled_execution_timezone,
-                "scheduled_execution_timezone",
-            ),
-            log_key=check.opt_list_param(log_key, "log_key", of_type=str),
-            timeout=check.opt_int_param(timeout, "timeout"),
+            repository_origin=repository_origin,
+            instance_ref=instance_ref,
+            schedule_name=schedule_name,
+            scheduled_execution_timestamp=scheduled_execution_timestamp,
+            scheduled_execution_timezone=scheduled_execution_timezone,
+            log_key=log_key if log_key is not None else [],
+            timeout=timeout,
         )
 
 
 @whitelist_for_serdes
-class SensorExecutionArgs(
-    NamedTuple(
-        "_SensorExecutionArgs",
-        [
-            ("repository_origin", RemoteRepositoryOrigin),
-            ("instance_ref", Optional[InstanceRef]),
-            ("sensor_name", str),
-            ("last_tick_completion_time", Optional[float]),
-            ("last_run_key", Optional[str]),
-            ("cursor", Optional[str]),
-            ("log_key", Optional[Sequence[str]]),
-            ("timeout", Optional[int]),
-            ("last_sensor_start_time", Optional[float]),
-            # deprecated
-            ("last_completion_time", Optional[float]),
-        ],
-    )
-):
+@record_custom
+class SensorExecutionArgs(IHaveNew):
+    repository_origin: RemoteRepositoryOrigin
+    instance_ref: Optional[InstanceRef]
+    sensor_name: str
+    last_tick_completion_time: Optional[float]
+    last_run_key: Optional[str]
+    cursor: Optional[str]
+    log_key: Sequence[str]
+    timeout: Optional[int]
+    last_sensor_start_time: Optional[float]
+    # deprecated
+    last_completion_time: Optional[float]
+
     def __new__(
         cls,
         repository_origin: RemoteRepositoryOrigin,
@@ -663,192 +448,83 @@ class SensorExecutionArgs(
         )
         return super().__new__(
             cls,
-            repository_origin=check.inst_param(
-                repository_origin, "repository_origin", RemoteRepositoryOrigin
-            ),
-            instance_ref=check.opt_inst_param(instance_ref, "instance_ref", InstanceRef),
-            sensor_name=check.str_param(sensor_name, "sensor_name"),
+            repository_origin=repository_origin,
+            instance_ref=instance_ref,
+            sensor_name=sensor_name,
             last_tick_completion_time=normalized_last_tick_completion_time,
-            last_run_key=check.opt_str_param(last_run_key, "last_run_key"),
-            cursor=check.opt_str_param(cursor, "cursor"),
-            log_key=check.opt_list_param(log_key, "log_key", of_type=str),
+            last_run_key=last_run_key,
+            cursor=cursor,
+            log_key=log_key if log_key is not None else [],
             timeout=timeout,
-            last_sensor_start_time=check.opt_float_param(
-                last_sensor_start_time, "last_sensor_start_time"
-            ),
+            last_sensor_start_time=last_sensor_start_time,
             last_completion_time=normalized_last_tick_completion_time,
         )
 
     def with_default_timeout(self, timeout: int) -> "SensorExecutionArgs":
         """If the timeout is not explicitly set, provides a default timeout which is used for the sensor execution."""
         if self.timeout is None:
-            return self._replace(timeout=timeout)
+            return copy(self, timeout=timeout)
         return self
 
 
 @whitelist_for_serdes
-class ExternalJobArgs(
-    NamedTuple(
-        "_ExternalJobArgs",
-        [
-            ("repository_origin", RemoteRepositoryOrigin),
-            ("instance_ref", InstanceRef),
-            ("name", str),
-        ],
-    )
-):
-    def __new__(
-        cls, repository_origin: RemoteRepositoryOrigin, instance_ref: InstanceRef, name: str
-    ):
-        return super().__new__(
-            cls,
-            repository_origin=check.inst_param(
-                repository_origin, "repository_origin", RemoteRepositoryOrigin
-            ),
-            instance_ref=check.inst_param(instance_ref, "instance_ref", InstanceRef),
-            name=check.str_param(name, "name"),
-        )
+@record
+class ExternalJobArgs:
+    repository_origin: RemoteRepositoryOrigin
+    instance_ref: InstanceRef
+    name: str
 
 
 @whitelist_for_serdes
-class ShutdownServerResult(
-    NamedTuple(
-        "_ShutdownServerResult",
-        [("success", bool), ("serializable_error_info", Optional[SerializableErrorInfo])],
-    )
-):
-    def __new__(cls, success: bool, serializable_error_info: Optional[SerializableErrorInfo]):
-        return super().__new__(
-            cls,
-            success=check.bool_param(success, "success"),
-            serializable_error_info=check.opt_inst_param(
-                serializable_error_info, "serializable_error_info", SerializableErrorInfo
-            ),
-        )
+@record
+class ShutdownServerResult:
+    success: bool
+    serializable_error_info: Optional[SerializableErrorInfo]
 
 
 @whitelist_for_serdes
-class CancelExecutionRequest(NamedTuple("_CancelExecutionRequest", [("run_id", str)])):
-    def __new__(cls, run_id: str):
-        return super().__new__(
-            cls,
-            run_id=check.str_param(run_id, "run_id"),
-        )
+@record
+class CancelExecutionRequest:
+    run_id: str
 
 
 @whitelist_for_serdes
-class CancelExecutionResult(
-    NamedTuple(
-        "_CancelExecutionResult",
-        [
-            ("success", bool),
-            ("message", Optional[str]),
-            ("serializable_error_info", Optional[SerializableErrorInfo]),
-        ],
-    )
-):
-    def __new__(
-        cls,
-        success: bool,
-        message: Optional[str],
-        serializable_error_info: Optional[SerializableErrorInfo],
-    ):
-        return super().__new__(
-            cls,
-            success=check.bool_param(success, "success"),
-            message=check.opt_str_param(message, "message"),
-            serializable_error_info=check.opt_inst_param(
-                serializable_error_info, "serializable_error_info", SerializableErrorInfo
-            ),
-        )
+@record
+class CancelExecutionResult:
+    success: bool
+    message: Optional[str]
+    serializable_error_info: Optional[SerializableErrorInfo]
 
 
 @whitelist_for_serdes
-class CanCancelExecutionRequest(NamedTuple("_CanCancelExecutionRequest", [("run_id", str)])):
-    def __new__(cls, run_id: str):
-        return super().__new__(
-            cls,
-            run_id=check.str_param(run_id, "run_id"),
-        )
+@record
+class CanCancelExecutionRequest:
+    run_id: str
 
 
 @whitelist_for_serdes
-class CanCancelExecutionResult(NamedTuple("_CancelExecutionResult", [("can_cancel", bool)])):
-    def __new__(cls, can_cancel: bool):
-        return super().__new__(
-            cls,
-            can_cancel=check.bool_param(can_cancel, "can_cancel"),
-        )
+@record
+class CanCancelExecutionResult:
+    can_cancel: bool
 
 
 @whitelist_for_serdes
-class StartRunResult(
-    NamedTuple(
-        "_StartRunResult",
-        [
-            ("success", bool),
-            ("message", Optional[str]),
-            ("serializable_error_info", Optional[SerializableErrorInfo]),
-        ],
-    )
-):
-    def __new__(
-        cls,
-        success: bool,
-        message: Optional[str],
-        serializable_error_info: Optional[SerializableErrorInfo],
-    ):
-        return super().__new__(
-            cls,
-            success=check.bool_param(success, "success"),
-            message=check.opt_str_param(message, "message"),
-            serializable_error_info=check.opt_inst_param(
-                serializable_error_info, "serializable_error_info", SerializableErrorInfo
-            ),
-        )
+@record
+class StartRunResult:
+    success: bool
+    message: Optional[str]
+    serializable_error_info: Optional[SerializableErrorInfo]
 
 
 @whitelist_for_serdes
-class GetCurrentImageResult(
-    NamedTuple(
-        "_GetCurrentImageResult",
-        [
-            ("current_image", Optional[str]),
-            ("serializable_error_info", Optional[SerializableErrorInfo]),
-        ],
-    )
-):
-    def __new__(
-        cls, current_image: Optional[str], serializable_error_info: Optional[SerializableErrorInfo]
-    ):
-        return super().__new__(
-            cls,
-            current_image=check.opt_str_param(current_image, "current_image"),
-            serializable_error_info=check.opt_inst_param(
-                serializable_error_info, "serializable_error_info", SerializableErrorInfo
-            ),
-        )
+@record
+class GetCurrentImageResult:
+    current_image: Optional[str]
+    serializable_error_info: Optional[SerializableErrorInfo]
 
 
 @whitelist_for_serdes
-class GetCurrentRunsResult(
-    NamedTuple(
-        "_GetCurrentRunsResult",
-        [
-            ("current_runs", Sequence[str]),
-            ("serializable_error_info", Optional[SerializableErrorInfo]),
-        ],
-    )
-):
-    def __new__(
-        cls,
-        current_runs: Sequence[str],
-        serializable_error_info: Optional[SerializableErrorInfo],
-    ):
-        return super().__new__(
-            cls,
-            current_runs=check.list_param(current_runs, "current_runs", of_type=str),
-            serializable_error_info=check.opt_inst_param(
-                serializable_error_info, "serializable_error_info", SerializableErrorInfo
-            ),
-        )
+@record
+class GetCurrentRunsResult:
+    current_runs: Sequence[str]
+    serializable_error_info: Optional[SerializableErrorInfo]

dagster/version.py

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

{dagster-1.12.10.dist-info → dagster-1.12.11.dist-info}/METADATA

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

{dagster-1.12.10.dist-info → dagster-1.12.11.dist-info}/RECORD

@@ -4,7 +4,7 @@ dagster/_annotations.py,sha256=GC7Rc8ZJZS9EpUuiCMyrtLZ5lsGGjPPkVtlmaClkt2o,1610
 dagster/_builtins.py,sha256=J6A1CE28JV0itz73hCaHIKoUknb1j5B3QO5Frx_hQuU,471
 dagster/_module_alias_map.py,sha256=KsLPXRga52UbPcEjFpOie8tvb7sGdNnikl3MUelYtVA,3349
 dagster/py.typed,sha256=la67KBlbjXN-_-DfGNcdOcjYumVpKG_Tkw-8n5dnGB4,8
-dagster/version.py,sha256=GX6pK-MXEc7Qkjz8JfsyRXF34LXYUDbzbFGeDjwSQ5c,24
+dagster/version.py,sha256=V9Hrmon3VMx6Fm-BKFFV3DZcAfdU2IO-xs1MB4F4LlI,24
 dagster/_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dagster/_api/get_server_id.py,sha256=sBjhjcHgB__iIN567QCJmTtBK6-v31VfjDsYNZIohVw,731
 dagster/_api/list_repositories.py,sha256=fbjMobgFKzwoMN825GEgDeCx1jzUlW2vPhPDuYIg93g,3905
@@ -117,8 +117,8 @@ dagster/_core/definitions/freshness_policy.py,sha256=cZwymSwKoLP0BpLQtASZvmD6HPA
 dagster/_core/definitions/graph_definition.py,sha256=E-t2_gb8DnNLBzK5urdpvhg0o0Iv-wXAycQ9fWc4ANE,52914
 dagster/_core/definitions/hook_definition.py,sha256=yVMCMHg1UTiGswM0LlvWWkKiDx-cfLON5SDKK13_p4s,6709
 dagster/_core/definitions/hook_invocation.py,sha256=QgG12U_H7krChdSl_slv6HY_H6L_NLbPvpiKuUj_ikU,1640
-dagster/_core/definitions/inference.py,sha256=WhvPqo4_AewcFlyrI5sG6gz-XiW0D6bPqFJ4OyAtp2Y,3322
-dagster/_core/definitions/input.py,sha256=vwB-WtXZutQIePiA2vj-4mlsUiK4p-5guuY5_E0NmlI,21007
+dagster/_core/definitions/inference.py,sha256=NbpIuSwziHTx2g5x_fEWmsNQY_lA69Ap-66x1QXc5iY,3375
+dagster/_core/definitions/input.py,sha256=lJIsJMNp8FNVKCHSKCwe6KmvNxYD6CbbjQ1no_GbJiQ,19723
 dagster/_core/definitions/instigation_logger.py,sha256=n0l2a7uWo6qlDB__zzONRNW-U6bnCuZeHxsV_kuIbX8,7396
 dagster/_core/definitions/job_base.py,sha256=o5FBiqml5le14TAiDPxmYRLSoW4-_G0N2HzeXvakME8,4293
 dagster/_core/definitions/job_definition.py,sha256=Hmon_NOwLvRCKSqPkaqr0AVjjhcQBOCRUqHma0ZPxNQ,62303
@@ -196,7 +196,7 @@ dagster/_core/definitions/assets/graph/asset_graph.py,sha256=7uC3IgCqjvVLlJ86G9K
 dagster/_core/definitions/assets/graph/asset_graph_differ.py,sha256=ZgyJa3tD-58a5y8SbU10jn60FHQECGA3-FrspkMPyyY,8338
 dagster/_core/definitions/assets/graph/asset_graph_subset.py,sha256=T44B8C2_J1UdnjCv-wROZHbAqACbGag06QM6dvpVgoI,17374
 dagster/_core/definitions/assets/graph/base_asset_graph.py,sha256=kCFBREioJyltAXCwIqbQYUC7QL9VZHn1zgwB54Gho4I,32842
-dagster/_core/definitions/assets/graph/remote_asset_graph.py,sha256=vCeHFRqHRb9W3PPZ0M8Kxw0_L6gna0LzLyjr2Jy9Rik,35164
+dagster/_core/definitions/assets/graph/remote_asset_graph.py,sha256=8ibrcDnJHM16dr4jORVMoZL8qX5etw70q5Uqn1VmI8s,35164
 dagster/_core/definitions/assets/job/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dagster/_core/definitions/assets/job/asset_in.py,sha256=c70Sx5_lH8C4aSRmOtL6mn2Jk18BFhpds-VWUcbMQBw,4065
 dagster/_core/definitions/assets/job/asset_job.py,sha256=FgJzVfsfDYUU8bHvNcTooGn3ROOnolrnjcsch8Wuk3o,30964
@@ -241,7 +241,7 @@ dagster/_core/definitions/decorators/sensor_decorator.py,sha256=BaieF1GcKdaONu3O
 dagster/_core/definitions/decorators/source_asset_decorator.py,sha256=KE9oCVlzaRNiUck_aP8n5vX7Ah8JQEOoXirwRW2E5YQ,14912
 dagster/_core/definitions/metadata/__init__.py,sha256=3udptTJSppffelN6ehwrArbfpS-LFwHa9MqYArTJqiA,10784
 dagster/_core/definitions/metadata/external_metadata.py,sha256=DphSm10HGxHACurNFhegFcAM8lOx67QePUsOyek6Yac,5040
-dagster/_core/definitions/metadata/metadata_set.py,sha256=nfEyUYSqHxWvM1mVohodLfxcLxv23wqz0KNiTlWs2x8,7801
+dagster/_core/definitions/metadata/metadata_set.py,sha256=28HSSrJrfmh2Oj7akTuGyjTBMXddQe6L4xO7pdaucIg,8204
 dagster/_core/definitions/metadata/metadata_value.py,sha256=vQdvYxfqWUWk7xe3sdNWmErTcyOx3iSJ7OSwuv-MJk8,33394
 dagster/_core/definitions/metadata/source_code.py,sha256=sc21_k_eH7ZaUeTQMWF3XYrBtCa3-yGSy9_gTiE149s,16350
 dagster/_core/definitions/metadata/table.py,sha256=PwXMIyKMn-eotPThhX6OPkyQqrealjs5KExo8WkTWU8,11097
@@ -670,7 +670,7 @@ dagster/_grpc/impl.py,sha256=KCQc0n1ySN4sB5PssKUg9jPXdOEMdAInXpGOEORuo_A,21868
 dagster/_grpc/proxy_server.py,sha256=2zpPc4i1c5yRL1VTZTYxuc1_SWv5VxyMTZI47uHkEVU,16166
 dagster/_grpc/server.py,sha256=WOy9Wq94d8f1Y8-7qFZmRCH5CT8k9kK_BpbTWRwKu7A,71129
 dagster/_grpc/server_watcher.py,sha256=Po38DqropGefgEztDsiRBR8iHCNoLxMlSJYcWf9t-HU,5793
-dagster/_grpc/types.py,sha256=e3j9ouLeDE0th8LPOhIyV_YevprQkO0AvO1yv0Xyf0A,30666
+dagster/_grpc/types.py,sha256=7U8E1N30BZRg3OTKAXC7nqoHDt8ndf1AAdBs017rNNs,17421
 dagster/_grpc/utils.py,sha256=1x9U8V7xdetXb48oKk04wggH52DVdoVgTWt41kBPO7Q,4438
 dagster/_grpc/__generated__/__init__.py,sha256=rnEgpZcRbLz3VvKFrCQgwdnZc5S9MV1fUhxvwrxEroU,190
 dagster/_grpc/__generated__/dagster_api_pb2.py,sha256=pYXoY-0mt7J548Pd1BxZrVkhshJ7lY3bbMXZr3WKAKc,13495
@@ -824,9 +824,9 @@ dagster/components/utils/translation.py,sha256=gKal6ZdMbYImiBLZVa9E2pz4690j8Hukf
 dagster/deprecated/__init__.py,sha256=fkuCwd_79EmS-Voox0YlWEHWxZwQ0ZM_V0viwxw5isw,127
 dagster/preview/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dagster/preview/freshness/__init__.py,sha256=zq0UU-3mnxycgJDtAZ9DFWiBh4eXxKCaKbeuRmUl3_Y,276
-dagster-1.12.10.dist-info/licenses/LICENSE,sha256=4lsMW-RCvfVD4_F57wrmpe3vX1xwUk_OAKKmV_XT7Z0,11348
-dagster-1.12.10.dist-info/METADATA,sha256=w6opX1P_6S3ZXRIUq6gHcZBmFBAh7egvvlFwTK0VB2A,12218
-dagster-1.12.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dagster-1.12.10.dist-info/entry_points.txt,sha256=D4W0jf1lM8zq82j3DJd9JkZEmHdFz5gkz8ddRzOEzpc,139
-dagster-1.12.10.dist-info/top_level.txt,sha256=Gx3NqlMQh6AsfIZaJJXEfep5yh-e9pUxkzOlUV3s6CM,8
-dagster-1.12.10.dist-info/RECORD,,
+dagster-1.12.11.dist-info/licenses/LICENSE,sha256=4lsMW-RCvfVD4_F57wrmpe3vX1xwUk_OAKKmV_XT7Z0,11348
+dagster-1.12.11.dist-info/METADATA,sha256=TiJ3mrw3erh1Ys5sxTcbYqH-trU8MRo9nChnNe48IXY,12218
+dagster-1.12.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dagster-1.12.11.dist-info/entry_points.txt,sha256=D4W0jf1lM8zq82j3DJd9JkZEmHdFz5gkz8ddRzOEzpc,139
+dagster-1.12.11.dist-info/top_level.txt,sha256=Gx3NqlMQh6AsfIZaJJXEfep5yh-e9pUxkzOlUV3s6CM,8
+dagster-1.12.11.dist-info/RECORD,,