dagster 1.12.6__tar.gz → 1.12.7__tar.gz

{dagster-1.12.6/dagster.egg-info → dagster-1.12.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dagster
-Version: 1.12.6
+Version: 1.12.7
 Summary: Dagster is an orchestration platform for the development, production, and observation of data assets.
 Author: Dagster Labs
 Author-email: hello@dagsterlabs.com
@@ -59,13 +59,12 @@ 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.6
-Requires-Dist: dagster-shared==1.12.6
+Requires-Dist: dagster-pipes==1.12.7
+Requires-Dist: dagster-shared==1.12.7
 Requires-Dist: antlr4-python3-runtime
 Provides-Extra: docker
 Requires-Dist: docker; extra == "docker"
 Provides-Extra: test
-Requires-Dist: buildkite-test-collector; extra == "test"
 Requires-Dist: docker; extra == "test"
 Requires-Dist: grpcio-tools>=1.44.0; extra == "test"
 Requires-Dist: mypy-protobuf; extra == "test"
@@ -199,7 +198,7 @@ Dagster is built to be used at every stage of the data development lifecycle - l
 
 If you're new to Dagster, we recommend checking out the [docs](https://docs.dagster.io) or following the hands-on [tutorial](https://docs.dagster.io/etl-pipeline-tutorial/).
 
-Dagster is available on PyPI and officially supports Python 3.9 through Python 3.13.
+Dagster is available on PyPI and officially supports Python 3.9 through Python 3.14.
 
 ```bash
 pip install dagster dagster-webserver

{dagster-1.12.6 → dagster-1.12.7}/README.md

@@ -71,7 +71,7 @@ Dagster is built to be used at every stage of the data development lifecycle - l
 
 If you're new to Dagster, we recommend checking out the [docs](https://docs.dagster.io) or following the hands-on [tutorial](https://docs.dagster.io/etl-pipeline-tutorial/).
 
-Dagster is available on PyPI and officially supports Python 3.9 through Python 3.13.
+Dagster is available on PyPI and officially supports Python 3.9 through Python 3.14.
 
 ```bash
 pip install dagster dagster-webserver

{dagster-1.12.6 → dagster-1.12.7}/dagster/_cli/api.py

@@ -67,10 +67,25 @@ def api_cli() -> None:
         "interactively."
     ),
 )
-@click.argument("input_json", type=click.STRING)
-def execute_run_command(input_json: str) -> None:
+@click.argument("input_json", type=click.STRING, envvar="DAGSTER_EXECUTE_RUN_ARGS", required=False)
+@click.option(
+    "compressed_input_json",
+    "--compressed-input-json",
+    type=click.STRING,
+    envvar="DAGSTER_COMPRESSED_EXECUTE_RUN_ARGS",
+)
+def execute_run_command(input_json: Optional[str], compressed_input_json: Optional[str]) -> None:
     with capture_interrupts():
-        args = deserialize_value(input_json, ExecuteRunArgs)
+        if input_json and not compressed_input_json:
+            normalized_input_json = input_json
+        elif compressed_input_json and not input_json:
+            normalized_input_json = zlib.decompress(
+                base64.b64decode(compressed_input_json.encode())
+            ).decode()
+        else:
+            check.failed("Must provide one of input_json or compressed_input_json")
+
+        args = deserialize_value(normalized_input_json, ExecuteRunArgs)
 
         with get_instance_for_cli(instance_ref=args.instance_ref) as instance:
             buffer = []

{dagster-1.12.6 → dagster-1.12.7}/dagster/_cli/asset.py

@@ -4,6 +4,7 @@ import click
 from dagster_shared.cli import python_pointer_options
 
 import dagster._check as check
+from dagster._annotations import superseded
 from dagster._cli.job import get_run_config_from_cli_opts
 from dagster._cli.utils import (
     assert_no_remaining_opts,
@@ -52,6 +53,10 @@ def asset_cli():
 )
 @run_config_option(name="config", command_name="materialize")
 @python_pointer_options
+@superseded(
+    additional_warn_text="Use 'dg launch --assets <selection>' instead.",
+    emit_runtime_warning=True,
+)
 def asset_materialize_command(
     select: str,
     partition: Optional[str],

{dagster-1.12.6 → dagster-1.12.7}/dagster/_cli/definitions.py

@@ -7,6 +7,7 @@ from dagster_shared.cli import workspace_options
 from dagster_shared.error import remove_system_frames_from_error
 
 from dagster import __version__ as dagster_version
+from dagster._annotations import superseded
 from dagster._cli.utils import assert_no_remaining_opts, get_possibly_temporary_instance_for_cli
 from dagster._cli.workspace.cli_target import WorkspaceOpts, get_workspace_from_cli_opts
 from dagster._utils.error import serializable_error_info_from_exc_info, unwrap_user_code_error
@@ -63,6 +64,10 @@ def definitions_cli():
     This command should be run in a Python environment where the `dagster` package is installed.
     """,
 )
+@superseded(
+    additional_warn_text="Use 'dg check defs' instead.",
+    emit_runtime_warning=True,
+)
 def definitions_validate_command(
     log_level: str,
     log_format: str,

{dagster-1.12.6 → dagster-1.12.7}/dagster/_cli/dev.py

@@ -20,7 +20,7 @@ from dagster_shared.ipc import (
 )
 from dagster_shared.serdes import serialize_value
 
-from dagster._annotations import deprecated
+from dagster._annotations import deprecated, superseded
 from dagster._cli.proxy_server_manager import ProxyServerManager
 from dagster._cli.utils import assert_no_remaining_opts, get_possibly_temporary_instance_for_cli
 from dagster._cli.workspace.cli_target import WorkspaceOpts, workspace_opts_to_load_target
@@ -110,6 +110,10 @@ _CHECK_SUBPROCESS_INTERVAL = 5
 @deprecated(
     breaking_version="2.0", subject="--dagit-port and --dagit-host args", emit_runtime_warning=False
 )
+@superseded(
+    additional_warn_text="Use 'dg dev' instead.",
+    emit_runtime_warning=True,
+)
 def dev_command(
     code_server_log_level: str,
     log_level: str,

{dagster-1.12.6 → dagster-1.12.7}/dagster/_cli/job.py

@@ -12,6 +12,7 @@ from dagster_shared.yaml_utils import dump_run_config_yaml
 
 import dagster._check as check
 from dagster import __version__ as dagster_version
+from dagster._annotations import superseded
 from dagster._check import checked
 from dagster._cli.config_scaffolder import scaffold_job_config
 from dagster._cli.utils import (
@@ -300,6 +301,10 @@ _OP_SELECTION_HELP = (
 @job_name_option(name="job_name")
 @run_config_option(name="config", command_name="execute")
 @python_pointer_options
+@superseded(
+    additional_warn_text="Use 'dg launch --job <job_name>' instead.",
+    emit_runtime_warning=True,
+)
 def job_execute_command(
     tags: Optional[str],
     op_selection: Optional[str],

{dagster-1.12.6 → dagster-1.12.7}/dagster/_cli/project.py

@@ -5,6 +5,7 @@ from typing import NamedTuple, Optional, Union
 
 import click
 
+from dagster._annotations import superseded
 from dagster._generate import download_example_from_github, generate_project, generate_repository
 from dagster._generate.download import AVAILABLE_EXAMPLES
 from dagster.version import __version__ as dagster_version
@@ -182,6 +183,10 @@ def scaffold_code_location_command(context, name: str):
     default=False,
     help="Controls whether the project name can conflict with an existing PyPI package.",
 )
+@superseded(
+    additional_warn_text="Use 'create-dagster project' instead.",
+    emit_runtime_warning=True,
+)
 def scaffold_command(
     name: str,
     excludes: Optional[Union[list[str], tuple]] = None,

{dagster-1.12.6 → dagster-1.12.7}/dagster/_config/pythonic_config/typing_utils.py

@@ -1,3 +1,4 @@
+import sys
 from typing import (
     TYPE_CHECKING,
     Annotated,
@@ -27,6 +28,24 @@ if TYPE_CHECKING:
     from dagster._config.pythonic_config import PartialResource
 
 
+def _materialize_annotations_for_pydantic(namespaces: dict[str, Any]) -> dict[str, Any]:
+    """Materialize lazy annotations in Python 3.14+ (PEP 649)."""
+    annotations = namespaces.get("__annotations__", {})
+
+    # if annotations are empty, try calling __annotate_func__ (PEP 649)
+    if sys.version_info >= (3, 14) and not annotations:
+        import annotationlib
+
+        annotate_func = annotationlib.get_annotate_from_class_namespace(namespaces)
+        if annotate_func is not None:
+            annotations = annotationlib.call_annotate_function(
+                annotate_func, annotationlib.Format.VALUE
+            )
+            namespaces["__annotations__"] = annotations
+
+    return annotations
+
+
 # Since a metaclass is invoked by Resource before Resource or PartialResource is defined, we need to
 # define a temporary class to use as a placeholder for use in the initial metaclass invocation.
 #
@@ -72,7 +91,8 @@ class LateBoundTypesForResourceTypeChecking:
 @dataclass_transform(kw_only_default=True, field_specifiers=(Field,))
 class BaseConfigMeta(ModelMetaclass):  # type: ignore
     def __new__(cls, name, bases, namespaces, **kwargs) -> Any:
-        annotations = namespaces.get("__annotations__", {})
+        # Materialize lazy annotations for Python 3.14+ before Pydantic sees them
+        annotations = _materialize_annotations_for_pydantic(namespaces)
 
         # Need try/catch because DagsterType may not be loaded when some of the base Config classes are
         # being created
@@ -118,11 +138,12 @@ class BaseResourceMeta(BaseConfigMeta):
         from pydantic.fields import FieldInfo
 
         # Gather all type annotations from the class and its base classes
-        annotations = namespaces.get("__annotations__", {})
+        # Materialize lazy annotations for Python 3.14+ before Pydantic sees them
+        annotations = _materialize_annotations_for_pydantic(namespaces)
+
         for field in annotations:
             if not field.startswith("__"):
                 # Check if the annotation is a ResourceDependency
-
                 if (
                     get_origin(annotations[field])
                     == LateBoundTypesForResourceTypeChecking.get_resource_rep_type()

{dagster-1.12.6 → dagster-1.12.7}/dagster/_core/definitions/__init__.py

@@ -124,9 +124,6 @@ from dagster._core.definitions.repository_definition import (
     RepositoryData as RepositoryData,
     RepositoryDefinition as RepositoryDefinition,
 )
-from dagster._core.definitions.resolved_asset_deps import (
-    ResolvedAssetDependencies as ResolvedAssetDependencies,
-)
 from dagster._core.definitions.resource_definition import (
     ResourceDefinition as ResourceDefinition,
     make_values_resource as make_values_resource,

{dagster-1.12.6 → dagster-1.12.7}/dagster/_core/definitions/asset_health/asset_materialization_health.py

@@ -36,6 +36,7 @@ class MinimalAssetMaterializationHealthState(LoadableBy[AssetKey]):
     num_currently_materialized_partitions: int
     partitions_snap: Optional[PartitionsSnap]
     latest_failed_to_materialize_timestamp: Optional[float] = None
+    latest_failed_to_materialize_run_id: Optional[str] = None
 
     @property
     def health_status(self) -> AssetHealthStatus:
@@ -64,6 +65,7 @@ class MinimalAssetMaterializationHealthState(LoadableBy[AssetKey]):
             num_currently_materialized_partitions=asset_materialization_health_state.currently_materialized_subset.size,
             partitions_snap=asset_materialization_health_state.partitions_snap,
             latest_failed_to_materialize_timestamp=asset_materialization_health_state.latest_failed_to_materialize_timestamp,
+            latest_failed_to_materialize_run_id=asset_materialization_health_state.latest_failed_to_materialize_run_id,
         )
 
     @classmethod
@@ -104,6 +106,7 @@ class AssetMaterializationHealthState(LoadableBy[AssetKey]):
     latest_terminal_run_id: Optional[str]
     latest_materialization_timestamp: Optional[float] = None
     latest_failed_to_materialize_timestamp: Optional[float] = None
+    latest_failed_to_materialize_run_id: Optional[str] = None
 
     @property
     def partitions_def(self) -> Optional[PartitionsDefinition]:
@@ -154,6 +157,7 @@ class AssetMaterializationHealthState(LoadableBy[AssetKey]):
                 check.failed("Expected partitions subset for a partitioned asset")
 
             last_run_id = None
+            last_failed_run_id = None
             latest_materialization_timestamp = None
             latest_failed_to_materialize_timestamp = None
             if asset_record is not None:
@@ -166,6 +170,11 @@ class AssetMaterializationHealthState(LoadableBy[AssetKey]):
                     key=lambda record: -1 if record is None else record.storage_id,
                 )
                 last_run_id = latest_record.run_id if latest_record else None
+                last_failed_run_id = (
+                    entry.last_failed_to_materialize_record.run_id
+                    if entry.last_failed_to_materialize_record
+                    else None
+                )
                 latest_materialization_timestamp = (
                     entry.last_materialization_record.timestamp
                     if entry.last_materialization_record
@@ -188,6 +197,7 @@ class AssetMaterializationHealthState(LoadableBy[AssetKey]):
                 latest_terminal_run_id=last_run_id,
                 latest_materialization_timestamp=latest_materialization_timestamp,
                 latest_failed_to_materialize_timestamp=latest_failed_to_materialize_timestamp,
+                latest_failed_to_materialize_run_id=last_failed_run_id,
             )
 
         if asset_record is None:
@@ -198,6 +208,7 @@ class AssetMaterializationHealthState(LoadableBy[AssetKey]):
                 latest_terminal_run_id=None,
                 latest_materialization_timestamp=None,
                 latest_failed_to_materialize_timestamp=None,
+                latest_failed_to_materialize_run_id=None,
             )
 
         asset_entry = asset_record.asset_entry
@@ -211,6 +222,11 @@ class AssetMaterializationHealthState(LoadableBy[AssetKey]):
             if asset_entry.last_failed_to_materialize_record
             else None
         )
+        latest_failed_run_id = (
+            asset_entry.last_failed_to_materialize_record.run_id
+            if asset_entry.last_failed_to_materialize_record
+            else None
+        )
         if asset_entry.last_run_id is None:
             return AssetMaterializationHealthState(
                 materialized_subset=SerializableEntitySubset(key=asset_key, value=False),
@@ -219,6 +235,7 @@ class AssetMaterializationHealthState(LoadableBy[AssetKey]):
                 latest_terminal_run_id=None,
                 latest_materialization_timestamp=latest_materialization_timestamp,
                 latest_failed_to_materialize_timestamp=latest_failed_to_materialize_timestamp,
+                latest_failed_to_materialize_run_id=latest_failed_run_id,
             )
 
         has_ever_materialized = asset_entry.last_materialization is not None
@@ -236,6 +253,7 @@ class AssetMaterializationHealthState(LoadableBy[AssetKey]):
             latest_terminal_run_id=latest_terminal_run_id,
             latest_materialization_timestamp=latest_materialization_timestamp,
             latest_failed_to_materialize_timestamp=latest_failed_to_materialize_timestamp,
+            latest_failed_to_materialize_run_id=latest_failed_run_id,
         )
 
     @classmethod
@@ -313,6 +331,8 @@ class AssetHealthMaterializationDegradedPartitionedMeta:
     num_failed_partitions: int
     num_missing_partitions: int
     total_num_partitions: int
+    latest_run_id: Optional[str] = None
+    latest_failed_to_materialize_run_id: Optional[str] = None
 
 
 @whitelist_for_serdes
@@ -320,6 +340,8 @@ class AssetHealthMaterializationDegradedPartitionedMeta:
 class AssetHealthMaterializationHealthyPartitionedMeta:
     num_missing_partitions: int
     total_num_partitions: int
+    latest_run_id: Optional[str] = None
+    latest_failed_to_materialize_run_id: Optional[str] = None
 
 
 @whitelist_for_serdes
@@ -421,6 +443,8 @@ async def get_materialization_status_and_metadata(
             meta = AssetHealthMaterializationHealthyPartitionedMeta(
                 num_missing_partitions=num_missing,
                 total_num_partitions=total_num_partitions,
+                latest_run_id=asset_materialization_health_state.latest_terminal_run_id,
+                latest_failed_to_materialize_run_id=asset_materialization_health_state.latest_failed_to_materialize_run_id,
             )
         else:
             # captures the case when asset is not partitioned, or the asset is partitioned and all partitions are materialized
@@ -441,10 +465,12 @@ async def get_materialization_status_and_metadata(
                 num_failed_partitions=asset_materialization_health_state.num_failed_partitions,
                 num_missing_partitions=num_missing,
                 total_num_partitions=total_num_partitions,
+                latest_run_id=asset_materialization_health_state.latest_terminal_run_id,
+                latest_failed_to_materialize_run_id=asset_materialization_health_state.latest_failed_to_materialize_run_id,
             )
         else:
             meta = AssetHealthMaterializationDegradedNotPartitionedMeta(
-                failed_run_id=asset_materialization_health_state.latest_terminal_run_id,
+                failed_run_id=asset_materialization_health_state.latest_failed_to_materialize_run_id,
             )
         return AssetHealthStatus.DEGRADED, meta
     elif asset_materialization_health_state.health_status == AssetHealthStatus.UNKNOWN:

{dagster-1.12.6 → dagster-1.12.7}/dagster/_core/definitions/assets/definition/asset_dep.py

@@ -1,5 +1,5 @@
-from collections.abc import Iterable, Sequence
-from typing import TYPE_CHECKING, NamedTuple, Optional, Union
+from collections.abc import Iterable, Mapping, Sequence
+from typing import TYPE_CHECKING, Any, NamedTuple, Optional, Union
 
 import dagster._check as check
 from dagster._annotations import PublicAttr, public
@@ -28,6 +28,7 @@ class AssetDep(
         [
             ("asset_key", PublicAttr[AssetKey]),
             ("partition_mapping", PublicAttr[Optional[PartitionMapping]]),
+            ("metadata", Mapping[str, Any]),
         ],
     )
 ):
@@ -60,6 +61,7 @@ class AssetDep(
         asset: Union[CoercibleToAssetKey, "AssetSpec", "AssetsDefinition", "SourceAsset"],
         *,
         partition_mapping: Optional[PartitionMapping] = None,
+        metadata: Optional[Mapping[str, Any]] = None,
     ):
         from dagster._core.definitions.assets.definition.asset_spec import AssetSpec
         from dagster._core.definitions.assets.definition.assets_definition import AssetsDefinition
@@ -93,6 +95,7 @@ class AssetDep(
                 "partition_mapping",
                 PartitionMapping,
             ),
+            metadata=check.opt_mapping_param(metadata, "metadata", key_type=str),
         )
 
     @staticmethod

{dagster-1.12.6 → dagster-1.12.7}/dagster/_core/definitions/assets/definition/asset_spec.py

@@ -97,8 +97,8 @@ class AssetExecutionType(Enum):
 
 
 def validate_kind_tags(kinds: Optional[AbstractSet[str]]) -> None:
-    if kinds is not None and len(kinds) > 3:
-        raise DagsterInvalidDefinitionError("Assets can have at most three kinds currently.")
+    if kinds is not None and len(kinds) > 10:
+        raise DagsterInvalidDefinitionError("Assets can have at most ten kinds currently.")
 
 
 @hidden_param(

{dagster-1.12.6 → dagster-1.12.7}/dagster/_core/definitions/assets/graph/asset_graph.py

@@ -4,11 +4,7 @@ from functools import cached_property
 from typing import AbstractSet, Optional, Union  # noqa: UP035
 
 from dagster._core.definitions.asset_checks.asset_check_spec import AssetCheckKey, AssetCheckSpec
-from dagster._core.definitions.assets.definition.asset_spec import (
-    SYSTEM_METADATA_KEY_AUTO_CREATED_STUB_ASSET,
-    AssetExecutionType,
-    AssetSpec,
-)
+from dagster._core.definitions.assets.definition.asset_spec import AssetExecutionType, AssetSpec
 from dagster._core.definitions.assets.definition.assets_definition import AssetsDefinition
 from dagster._core.definitions.assets.graph.base_asset_graph import (
     AssetCheckNode,
@@ -27,7 +23,10 @@ from dagster._core.definitions.freshness_policy import LegacyFreshnessPolicy
 from dagster._core.definitions.metadata import ArbitraryMetadataMapping
 from dagster._core.definitions.partitions.definition import PartitionsDefinition
 from dagster._core.definitions.partitions.mapping import PartitionMapping
-from dagster._core.definitions.resolved_asset_deps import ResolvedAssetDependencies
+from dagster._core.definitions.resolved_asset_deps import (
+    resolve_assets_def_deps,
+    resolve_stub_assets_defs,
+)
 from dagster._core.definitions.source_asset import SourceAsset
 from dagster._core.definitions.utils import DEFAULT_GROUP_NAME
 from dagster._core.selector.subset_selector import generate_asset_dep_graph
@@ -216,55 +215,14 @@ class AssetGraph(BaseAssetGraph[AssetNode]):
             create_external_asset_from_source_asset(a) if isinstance(a, SourceAsset) else a
             for a in assets
         ]
-        all_keys = {k for asset_def in assets_defs for k in asset_def.keys}
-
-        # Resolve all asset dependencies. An asset dependency is resolved when its key is an
-        # AssetKey not subject to any further manipulation.
-        resolved_deps = ResolvedAssetDependencies(assets_defs, [])
-
-        asset_key_replacements = [
-            {
-                raw_key: normalized_key
-                for input_name, raw_key in ad.keys_by_input_name.items()
-                if (
-                    normalized_key := resolved_deps.get_resolved_asset_key_for_input(ad, input_name)
-                )
-                != raw_key
-            }
-            for ad in assets_defs
-        ]
-
-        # Only update the assets defs if we're actually replacing input asset keys
-        assets_defs = [
-            ad.with_attributes(asset_key_replacements=reps) if reps else ad
-            for ad, reps in zip(assets_defs, asset_key_replacements)
-        ]
-
-        # Create unexecutable external assets definitions for any referenced keys for which no
-        # definition was provided.
-        all_referenced_asset_keys = {
-            key for assets_def in assets_defs for key in assets_def.dependency_keys
-        }.union(
-            {
-                check_spec.key.asset_key
-                for assets_def in assets_defs
-                for check_spec in assets_def.node_check_specs_by_output_name.values()
-            }
-        )
 
         with disable_dagster_warnings():
-            for key in all_referenced_asset_keys.difference(all_keys):
-                assets_defs.append(
-                    AssetsDefinition(
-                        specs=[
-                            AssetSpec(
-                                key=key,
-                                metadata={SYSTEM_METADATA_KEY_AUTO_CREATED_STUB_ASSET: True},
-                            )
-                        ]
-                    )
-                )
-        return assets_defs
+            # Resolve all asset dependency keys to their final values
+            assets_defs = resolve_assets_def_deps(assets_defs)
+            # Create stub assets for any referenced keys for which no definition was provided.
+            stub_assets_defs = resolve_stub_assets_defs(assets_defs)
+
+        return assets_defs + stub_assets_defs
 
     @classmethod
     def key_mappings_from_assets(

{dagster-1.12.6 → dagster-1.12.7}/dagster/_core/definitions/assets/graph/asset_graph_subset.py

@@ -180,7 +180,10 @@ class AssetGraphSubset(NamedTuple):
 
         for asset_key in other.asset_keys:
             if asset_key in other.non_partitioned_asset_keys:
-                check.invariant(asset_key not in self.partitions_subsets_by_asset_key)
+                check.invariant(
+                    asset_key not in self.partitions_subsets_by_asset_key,
+                    f"Asset {asset_key} is partitioned in one subset and non-partitioned in the other",
+                )
                 result_non_partitioned_asset_keys = oper(
                     result_non_partitioned_asset_keys, {asset_key}
                 )

{dagster-1.12.6 → dagster-1.12.7}/dagster/_core/definitions/decorators/decorator_assets_definition_builder.py

@@ -652,8 +652,15 @@ class DecoratorAssetsDefinitionBuilder:
 
     def _synthesize_specs(self) -> Sequence[AssetSpec]:
         resolved_specs = []
+        upstream_asset_dep_metadata_by_key = {
+            dep.asset_key: dep.metadata for dep in self.args.upstream_asset_deps or []
+        }
         input_deps_by_key = {
-            key: AssetDep(asset=key, partition_mapping=self.partition_mappings.get(key))
+            key: AssetDep(
+                asset=key,
+                partition_mapping=self.partition_mappings.get(key),
+                metadata=upstream_asset_dep_metadata_by_key.get(key),
+            )
             for key in self.asset_keys_by_input_names.values()
         }
         input_deps = list(input_deps_by_key.values())

{dagster-1.12.6 → dagster-1.12.7}/dagster/_core/definitions/op_definition.py

@@ -140,7 +140,8 @@ class OpDefinition(NodeDefinition, IHasInternalInit):
 
         ins = check.opt_mapping_param(ins, "ins")
         input_defs = [
-            inp.to_definition(name) for name, inp in sorted(ins.items(), key=lambda inp: inp[0])
+            inp if isinstance(inp, InputDefinition) else inp.to_definition(name)
+            for name, inp in sorted(ins.items(), key=lambda inp: inp[0])
         ]  # sort so that input definition order is deterministic
 
         if isinstance(compute_fn, DecoratedOpFunction):