This is an automated email from the ASF dual-hosted git repository.

uranusjr pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/airflow.git


The following commit(s) were added to refs/heads/main by this push:
     new 7a63bc2a89f Better typing in asset event accessors (#49488)
7a63bc2a89f is described below

commit 7a63bc2a89fed3ea78bfb359f582dd1164fb0ba6
Author: Tzu-ping Chung <[email protected]>
AuthorDate: Mon Apr 21 15:10:28 2025 +0800

    Better typing in asset event accessors (#49488)
---
 task-sdk/src/airflow/sdk/execution_time/context.py | 109 ++++++++++++---------
 1 file changed, 61 insertions(+), 48 deletions(-)

diff --git a/task-sdk/src/airflow/sdk/execution_time/context.py 
b/task-sdk/src/airflow/sdk/execution_time/context.py
index 9a4f02854e5..83ad09c90fb 100644
--- a/task-sdk/src/airflow/sdk/execution_time/context.py
+++ b/task-sdk/src/airflow/sdk/execution_time/context.py
@@ -20,7 +20,7 @@ import collections
 import contextlib
 from collections.abc import Generator, Iterable, Iterator, Mapping, Sequence
 from functools import cache
-from typing import TYPE_CHECKING, Any, Generic, TypeVar, Union
+from typing import TYPE_CHECKING, Any, Generic, TypeVar, overload
 
 import attrs
 import structlog
@@ -395,50 +395,6 @@ class _AssetRefResolutionMixin:
         return Asset(**msg.model_dump(exclude={"type"}))
 
 
[email protected]
-class TriggeringAssetEventsAccessor(
-    _AssetRefResolutionMixin,
-    Mapping[Union[Asset, AssetAlias, AssetRef], 
Sequence["AssetEventDagRunReferenceResult"]],
-):
-    """Lazy mapping of triggering asset events."""
-
-    _events: Mapping[BaseAssetUniqueKey, 
Sequence[AssetEventDagRunReferenceResult]]
-
-    @classmethod
-    def build(cls, events: Iterable[AssetEventDagRunReferenceResult]) -> 
TriggeringAssetEventsAccessor:
-        coll: dict[BaseAssetUniqueKey, list[AssetEventDagRunReferenceResult]] 
= collections.defaultdict(list)
-        for event in events:
-            coll[AssetUniqueKey(name=event.asset.name, 
uri=event.asset.uri)].append(event)
-            for alias in event.source_aliases:
-                coll[AssetAliasUniqueKey(name=alias.name)].append(event)
-        return cls(coll)
-
-    def __str__(self) -> str:
-        return f"TriggeringAssetEventAccessor(_events={self._events})"
-
-    def __iter__(self) -> Iterator[Asset | AssetAlias]:
-        return (
-            key.to_asset() if isinstance(key, AssetUniqueKey) else 
key.to_asset_alias()
-            for key in self._events
-        )
-
-    def __len__(self) -> int:
-        return len(self._events)
-
-    def __getitem__(self, key: Asset | AssetAlias | AssetRef) -> 
Sequence[AssetEventDagRunReferenceResult]:
-        hashable_key: BaseAssetUniqueKey
-        if isinstance(key, Asset):
-            hashable_key = AssetUniqueKey.from_asset(key)
-        elif isinstance(key, AssetRef):
-            hashable_key = self._resolve_asset_ref(key)
-        elif isinstance(key, AssetAlias):
-            hashable_key = AssetAliasUniqueKey.from_asset_alias(key)
-        else:
-            raise TypeError(f"Key should be either an asset or an asset alias, 
not {type(key)}")
-
-        return self._events[hashable_key]
-
-
 @attrs.define
 class OutletEventAccessor(_AssetRefResolutionMixin):
     """Wrapper to access an outlet asset event in template."""
@@ -467,6 +423,15 @@ class OutletEventAccessor(_AssetRefResolutionMixin):
 
 
 class _AssetEventAccessorsMixin(Generic[T]):
+    @overload
+    def for_asset(self, *, name: str, uri: str) -> T: ...
+
+    @overload
+    def for_asset(self, *, name: str) -> T: ...
+
+    @overload
+    def for_asset(self, *, uri: str) -> T: ...
+
     def for_asset(self, *, name: str | None = None, uri: str | None = None) -> 
T:
         if name and uri:
             return self[Asset(name=name, uri=uri)]
@@ -486,8 +451,8 @@ class _AssetEventAccessorsMixin(Generic[T]):
 
 class OutletEventAccessors(
     _AssetRefResolutionMixin,
-    Mapping[Union[Asset, AssetAlias], OutletEventAccessor],
-    _AssetEventAccessorsMixin,
+    Mapping["Asset | AssetAlias", OutletEventAccessor],
+    _AssetEventAccessorsMixin[OutletEventAccessor],
 ):
     """Lazy mapping of outlet asset event accessors."""
 
@@ -522,7 +487,10 @@ class OutletEventAccessors(
 
 
 @attrs.define(init=False)
-class InletEventsAccessors(Mapping[Union[int, Asset, AssetAlias, AssetRef], 
Any], _AssetEventAccessorsMixin):
+class InletEventsAccessors(
+    Mapping["int | Asset | AssetAlias | AssetRef", Any],
+    _AssetEventAccessorsMixin[list["AssetEventResult"]],
+):
     """Lazy mapping of inlet asset event accessors."""
 
     _inlets: list[Any]
@@ -597,6 +565,51 @@ class InletEventsAccessors(Mapping[Union[int, Asset, 
AssetAlias, AssetRef], Any]
         return list(msg.iter_asset_event_results())
 
 
[email protected]
+class TriggeringAssetEventsAccessor(
+    _AssetRefResolutionMixin,
+    Mapping["Asset | AssetAlias | AssetRef", 
Sequence["AssetEventDagRunReferenceResult"]],
+    _AssetEventAccessorsMixin[Sequence["AssetEventDagRunReferenceResult"]],
+):
+    """Lazy mapping of triggering asset events."""
+
+    _events: Mapping[BaseAssetUniqueKey, 
Sequence[AssetEventDagRunReferenceResult]]
+
+    @classmethod
+    def build(cls, events: Iterable[AssetEventDagRunReferenceResult]) -> 
TriggeringAssetEventsAccessor:
+        coll: dict[BaseAssetUniqueKey, list[AssetEventDagRunReferenceResult]] 
= collections.defaultdict(list)
+        for event in events:
+            coll[AssetUniqueKey(name=event.asset.name, 
uri=event.asset.uri)].append(event)
+            for alias in event.source_aliases:
+                coll[AssetAliasUniqueKey(name=alias.name)].append(event)
+        return cls(coll)
+
+    def __str__(self) -> str:
+        return f"TriggeringAssetEventAccessor(_events={self._events})"
+
+    def __iter__(self) -> Iterator[Asset | AssetAlias]:
+        return (
+            key.to_asset() if isinstance(key, AssetUniqueKey) else 
key.to_asset_alias()
+            for key in self._events
+        )
+
+    def __len__(self) -> int:
+        return len(self._events)
+
+    def __getitem__(self, key: Asset | AssetAlias | AssetRef) -> 
Sequence[AssetEventDagRunReferenceResult]:
+        hashable_key: BaseAssetUniqueKey
+        if isinstance(key, Asset):
+            hashable_key = AssetUniqueKey.from_asset(key)
+        elif isinstance(key, AssetRef):
+            hashable_key = self._resolve_asset_ref(key)
+        elif isinstance(key, AssetAlias):
+            hashable_key = AssetAliasUniqueKey.from_asset_alias(key)
+        else:
+            raise TypeError(f"Key should be either an asset or an asset alias, 
not {type(key)}")
+
+        return self._events[hashable_key]
+
+
 @cache  # Prevent multiple API access.
 def get_previous_dagrun_success(ti_id: UUID) -> PrevSuccessfulDagRunResponse:
     from airflow.sdk.execution_time.comms import (

Reply via email to