lsst-pipe-base 30.0.0rc3__py3-none-any.whl → 30.0.1rc1__py3-none-any.whl

lsst/pipe/base/pipeline_graph/_dataset_types.py

@@ -106,8 +106,8 @@ class DatasetTypeNode:
             The internal networkx graph.
         get_registered : `~collections.abc.Callable` or `None`
             Callable that takes a dataset type name and returns the
-            `DatasetType` registered in the data repository, or `None` if it is
-            not registered.
+            `~lsst.daf.butler.DatasetType` registered in the data repository,
+            or `None` if it is not registered.
         dimensions : `lsst.daf.butler.DimensionUniverse`
             Definitions of all dimensions.
         previous : `DatasetTypeNode` or `None`

lsst/pipe/base/pipeline_graph/_edges.py

@@ -30,7 +30,7 @@ __all__ = ("Edge", "ReadEdge", "WriteEdge")
 
 from abc import ABC, abstractmethod
 from collections.abc import Callable, Mapping, Sequence
-from typing import Any, ClassVar, Self, TypeVar
+from typing import Any, ClassVar, Self
 
 from lsst.daf.butler import DatasetRef, DatasetType, DimensionUniverse, StorageClassFactory
 from lsst.daf.butler.registry import MissingDatasetTypeError
@@ -40,8 +40,6 @@ from ..connectionTypes import BaseConnection
 from ._exceptions import ConnectionTypeConsistencyError, IncompatibleDatasetTypeError
 from ._nodes import NodeKey, NodeType
 
-_S = TypeVar("_S", bound="Edge")
-
 
 @immutable
 class Edge(ABC):
@@ -172,7 +170,7 @@ class Edge(ABC):
         """
         return self.parent_dataset_type_name
 
-    def diff(self: _S, other: _S, connection_type: str = "connection") -> list[str]:
+    def diff[S: Edge](self: S, other: S, connection_type: str = "connection") -> list[str]:
         """Compare this edge to another one from a possibly-different
         configuration of the same task label.
 
@@ -480,11 +478,11 @@ class ReadEdge(Edge):
         Parameters
         ----------
         current : `lsst.daf.butler.DatasetType` or `None`
-            The current graph-wide `DatasetType`, or `None`.  This will always
-            be the registry's definition of the parent dataset type, if one
-            exists.  If not, it will be the dataset type definition from the
-            task in the graph that writes it, if there is one.  If there is no
-            such task, this will be `None`.
+            The current graph-wide `~lsst.daf.butler.DatasetType`, or `None`.
+            This will always be the registry's definition of the parent dataset
+            type, if one exists.  If not, it will be the dataset type
+            definition from the task in the graph that writes it, if there is
+            one.  If there is no such task, this will be `None`.
         is_initial_query_constraint : `bool`
             Whether this dataset type is currently marked as a constraint on
             the initial data ID query in QuantumGraph generation.
@@ -496,7 +494,7 @@ class ReadEdge(Edge):
         producer : `str` or `None`
             The label of the task that produces this dataset type in the
             pipeline, or `None` if it is an overall input.
-        consumers : `Sequence` [ `str` ]
+        consumers : `~collections.abc.Sequence` [ `str` ]
             Labels for other consuming tasks that have already participated in
             this dataset type's resolution.
         is_registered : `bool`
@@ -512,7 +510,7 @@ class ReadEdge(Edge):
 
         Returns
         -------
-        dataset_type : `DatasetType`
+        dataset_type : `~lsst.daf.butler.DatasetType`
             The updated graph-wide dataset type.  If ``current`` was provided,
             this must be equal to it.
         is_initial_query_constraint : `bool`
@@ -659,13 +657,25 @@ class ReadEdge(Edge):
                     # compatible), since neither connection should take
                     # precedence.
                     if dataset_type != current:
-                        raise MissingDatasetTypeError(
-                            f"Definitions differ for input dataset type {self.parent_dataset_type_name!r}; "
-                            f"task {self.task_label!r} has {dataset_type}, but the definition "
-                            f"from {report_current_origin()} is {current}.  If the storage classes are "
-                            "compatible but different, registering the dataset type in the data repository "
-                            "in advance will avoid this error."
-                        )
+                        if visualization_only and dataset_type.dimensions == current.dimensions:
+                            # Make a visualization-only ambiguous storage class
+                            # "name".
+                            all_storage_classes = set(current.storageClass_name.split("/"))
+                            all_storage_classes.update(dataset_type.storageClass_name.split("/"))
+                            current = DatasetType(
+                                current.name,
+                                current.dimensions,
+                                "/".join(sorted(all_storage_classes)),
+                            )
+                        else:
+                            raise MissingDatasetTypeError(
+                                f"Definitions differ for input dataset type "
+                                f"{self.parent_dataset_type_name!r}; task {self.task_label!r} has "
+                                f"{dataset_type}, but the definition from {report_current_origin()} is "
+                                f"{current}.  If the storage classes are compatible but different, "
+                                "registering the dataset type in the data repository in advance will avoid "
+                                "this error."
+                            )
                 elif not visualization_only and not dataset_type.is_compatible_with(current):
                     raise IncompatibleDatasetTypeError(
                         f"Incompatible definition for input dataset type {self.parent_dataset_type_name!r}; "
@@ -788,15 +798,15 @@ class WriteEdge(Edge):
         Parameters
         ----------
         current : `lsst.daf.butler.DatasetType` or `None`
-            The current graph-wide `DatasetType`, or `None`.  This will always
-            be the registry's definition of the parent dataset type, if one
-            exists.
+            The current graph-wide `~lsst.daf.butler.DatasetType`, or `None`.
+            This will always be the registry's definition of the parent dataset
+            type, if one exists.
         universe : `lsst.daf.butler.DimensionUniverse`
             Object that holds all dimension definitions.
 
         Returns
         -------
-        dataset_type : `DatasetType`
+        dataset_type : `~lsst.daf.butler.DatasetType`
             A dataset type compatible with this edge.  If ``current`` was
             provided, this must be equal to it.
 

lsst/pipe/base/pipeline_graph/_mapping_views.py

@@ -27,7 +27,7 @@
 from __future__ import annotations
 
 from collections.abc import Iterable, Iterator, Mapping, Sequence
-from typing import Any, ClassVar, TypeVar, cast, overload
+from typing import Any, ClassVar, cast, overload
 
 import networkx
 
@@ -36,11 +36,8 @@ from ._exceptions import UnresolvedGraphError
 from ._nodes import NodeKey, NodeType
 from ._tasks import TaskInitNode, TaskNode
 
-_N = TypeVar("_N", covariant=True)
-_T = TypeVar("_T")
 
-
-class MappingView(Mapping[str, _N]):
+class MappingView[N](Mapping[str, N]):
     """Base class for mapping views into nodes of certain types in a
     `PipelineGraph`.
 
@@ -74,7 +71,7 @@ class MappingView(Mapping[str, _N]):
             self._keys = self._make_keys(self._parent_xgraph)
         return iter(self._keys)
 
-    def __getitem__(self, key: str) -> _N:
+    def __getitem__(self, key: str) -> N:
         return self._parent_xgraph.nodes[NodeKey(self._NODE_TYPE, key)]["instance"]
 
     def __len__(self) -> int:
@@ -230,7 +227,7 @@ class DatasetTypeMappingView(MappingView[DatasetTypeNode]):
     def get_if_resolved(self, key: str) -> DatasetTypeNode | None: ...  # pragma: nocover
 
     @overload
-    def get_if_resolved(self, key: str, default: _T) -> DatasetTypeNode | _T: ...  # pragma: nocover
+    def get_if_resolved[T](self, key: str, default: T) -> DatasetTypeNode | T: ...  # pragma: nocover
 
     def get_if_resolved(self, key: str, default: Any = None) -> DatasetTypeNode | Any:
         """Get a node or return a default if it has not been resolved.

lsst/pipe/base/pipeline_graph/_pipeline_graph.py

@@ -33,7 +33,7 @@ import itertools
 import json
 import logging
 from collections.abc import Callable, Iterable, Iterator, Mapping, Sequence, Set
-from typing import TYPE_CHECKING, Any, BinaryIO, Literal, TypeVar, cast
+from typing import TYPE_CHECKING, Any, BinaryIO, Literal, cast
 
 import networkx
 import networkx.algorithms.bipartite
@@ -79,9 +79,6 @@ if TYPE_CHECKING:
     from ..pipeline import TaskDef
     from ..pipelineTask import PipelineTask
 
-
-_G = TypeVar("_G", bound=networkx.DiGraph | networkx.MultiDiGraph)
-
 _LOG = logging.getLogger("lsst.pipe.base.pipeline_graph")
 
 
@@ -897,6 +894,10 @@ class PipelineGraph:
             New config objects or overrides to apply to copies of the current
             config objects, with task labels as the keywords.
 
+        Returns
+        -------
+        None
+
         Raises
         ------
         ValueError
@@ -1632,7 +1633,7 @@ class PipelineGraph:
 
         Returns
         -------
-        subgraphs : `Iterable` [ `PipelineGraph` ]
+        subgraphs : `~collections.abc.Iterable` [ `PipelineGraph` ]
             An iterable over component subgraphs that could be run
             independently (they have only overall inputs in common).  May be a
             lazy iterator.
@@ -1755,6 +1756,10 @@ class PipelineGraph:
             not considered part of the pipeline graph in other respects, but it
             does get written with other provenance datasets).
 
+        Returns
+        -------
+        None
+
         Raises
         ------
         lsst.daf.butler.MissingDatasetTypeError
@@ -2179,7 +2184,9 @@ class PipelineGraph:
         ]
         return networkx.algorithms.bipartite.projected_graph(networkx.DiGraph(bipartite_xgraph), task_keys)
 
-    def _transform_xgraph_state(self, xgraph: _G, skip_edges: bool) -> _G:
+    def _transform_xgraph_state[G: networkx.DiGraph | networkx.MultiDiGraph](
+        self, xgraph: G, skip_edges: bool
+    ) -> G:
         """Transform networkx graph attributes in-place from the internal
         "instance" attributes to the documented exported attributes.
 
@@ -2228,7 +2235,7 @@ class PipelineGraph:
 
         Parameters
         ----------
-        updates : `Mapping` [ `str`, `TaskNode` ]
+        updates : `~collections.abc.Mapping` [ `str`, `TaskNode` ]
             New task nodes with task label keys.  All keys must be task labels
             that are already present in the graph.
         check_edges_unchanged : `bool`, optional

lsst/pipe/base/pipeline_graph/expressions.py

@@ -43,7 +43,7 @@ __all__ = (
 
 import dataclasses
 import functools
-from typing import TYPE_CHECKING, Any, Literal, TypeAlias
+from typing import TYPE_CHECKING, Any, Literal
 
 from lsst.daf.butler.queries.expressions.parser.ply import lex, yacc
 
@@ -268,4 +268,4 @@ def parse(expression: str) -> Node:
     return _ParserYacc().parse(expression)
 
 
-Node: TypeAlias = IdentifierNode | DirectionNode | NotNode | UnionNode | IntersectionNode
+type Node = IdentifierNode | DirectionNode | NotNode | UnionNode | IntersectionNode

lsst/pipe/base/pipeline_graph/io.py

@@ -33,11 +33,10 @@ __all__ = (
     "SerializedTaskInitNode",
     "SerializedTaskNode",
     "SerializedTaskSubset",
-    "expect_not_none",
 )
 
 from collections.abc import Mapping
-from typing import Any, TypeVar
+from typing import Any
 
 import networkx
 import pydantic
@@ -53,14 +52,12 @@ from ._pipeline_graph import PipelineGraph
 from ._task_subsets import StepDefinitions, TaskSubset
 from ._tasks import TaskImportMode, TaskInitNode, TaskNode
 
-_U = TypeVar("_U")
-
 _IO_VERSION_INFO = (0, 0, 1)
 """Version tuple embedded in saved PipelineGraphs.
 """
 
 
-def expect_not_none(value: _U | None, msg: str) -> _U:
+def _expect_not_none[U](value: U | None, msg: str) -> U:
     """Check that a value is not `None` and return it.
 
     Parameters
@@ -418,7 +415,7 @@ class SerializedTaskNode(pydantic.BaseModel):
         init = self.init.deserialize(
             init_key,
             task_class_name=self.task_class,
-            config_str=expect_not_none(
+            config_str=_expect_not_none(
                 self.config_str, f"No serialized config file for task with label {key.name!r}."
             ),
             dataset_type_keys=dataset_type_keys,
@@ -547,16 +544,16 @@ class SerializedDatasetTypeNode(pydantic.BaseModel):
         if self.dimensions is not None:
             dataset_type = DatasetType(
                 key.name,
-                expect_not_none(
+                _expect_not_none(
                     self.dimensions,
                     f"Serialized dataset type {key.name!r} has no dimensions.",
                 ),
-                storageClass=expect_not_none(
+                storageClass=_expect_not_none(
                     self.storage_class,
                     f"Serialized dataset type {key.name!r} has no storage class.",
                 ),
                 isCalibration=self.is_calibration,
-                universe=expect_not_none(
+                universe=_expect_not_none(
                     universe,
                     f"Serialized dataset type {key.name!r} has dimensions, "
                     "but no dimension universe was stored.",
@@ -747,7 +744,7 @@ class SerializedPipelineGraph(pydantic.BaseModel):
         if self.dimensions is not None:
             universe = DimensionUniverse(
                 config=DimensionConfig(
-                    expect_not_none(
+                    _expect_not_none(
                         self.dimensions,
                         "Serialized pipeline graph has not been resolved; "
                         "load it is a MutablePipelineGraph instead.",

lsst/pipe/base/pipeline_graph/visualization/_dot.py

@@ -66,7 +66,7 @@ def show_dot(
     ----------
     pipeline_graph : `PipelineGraph`
         Pipeline graph to show.
-    stream : `TextIO`, optional
+    stream : `io.TextIO`, optional
         Stream to write the DOT representation to.
     label_edge_connections : `bool`, optional
         If `True`, label edges with their connection names.
@@ -167,21 +167,22 @@ def _render_dataset_type_node(
 
     Parameters
     ----------
-    node_key : NodeKey
-        The key for the node
-    node_data : Mapping[str, Any]
-        The data associated with the node
-    options : NodeAttributeOptions
-        Options for rendering the node
-    stream : TextIO
-        The stream to write the node to
+    node_key : `NodeKey`
+        The key for the node.
+    node_data : `~collections.abc.Mapping` [`str`, `typing.Any`]
+        The data associated with the node.
+    options : `NodeAttributeOptions`
+        Options for rendering the node.
+    stream : `io.TextIO`
+        The stream to write the node to.
+    overflow_ref : `int`, optional
 
     Returns
     -------
     overflow_ref : int
-        The reference number for the next overflow node
+        The reference number for the next overflow node.
     overflow_ids : str | None
-        The ID of the overflow node, if any
+        The ID of the overflow node, if any.
     """
     labels, label_extras, common_prefix = _format_label(str(node_key), _LABEL_MAX_LINES_SOFT)
     if len(labels) + len(label_extras) <= _LABEL_MAX_LINES_HARD:
@@ -271,7 +272,7 @@ def _render_edge(from_node_id: str, to_node_id: str, stream: TextIO, **kwargs: A
         The unique ID of the node the edge is going to
     stream : TextIO
         The stream to write the edge to
-    kwargs : Any
+    **kwargs : Any
         Additional keyword arguments to pass to the edge
     """
     if kwargs:

lsst/pipe/base/pipeline_graph/visualization/_layout.py

@@ -30,7 +30,7 @@ __all__ = ("ColumnSelector", "Layout", "LayoutRow")
 
 import dataclasses
 from collections.abc import Iterable, Iterator, Mapping, Set
-from typing import Generic, TextIO, TypeVar
+from typing import TextIO
 
 import networkx
 import networkx.algorithms.components
@@ -38,10 +38,8 @@ import networkx.algorithms.dag
 import networkx.algorithms.shortest_paths
 import networkx.algorithms.traversal
 
-_K = TypeVar("_K")
 
-
-class Layout(Generic[_K]):
+class Layout[K]:
     """A class that positions nodes and edges in text-art graph visualizations.
 
     Parameters
@@ -73,9 +71,9 @@ class Layout(Generic[_K]):
         # to be close to that text when possible (or maybe it's historical, and
         # it's just a lot of work to re-invert the algorithm now that it's
         # written).
-        self._active_columns: dict[int, set[_K]] = {}
+        self._active_columns: dict[int, set[K]] = {}
         # Mapping from node key to its column.
-        self._locations: dict[_K, int] = {}
+        self._locations: dict[K, int] = {}
         # Minimum and maximum column (may go negative; will be shifted as
         # needed before actual display).
         self._x_min = 0
@@ -116,7 +114,7 @@ class Layout(Generic[_K]):
         for component_xgraph, component_order in component_xgraphs_and_orders:
             self._add_connected_graph(component_xgraph, component_order)
 
-    def _add_single_node(self, node: _K) -> None:
+    def _add_single_node(self, node: K) -> None:
         """Add a single node to the layout."""
         assert node not in self._locations
         if not self._locations:
@@ -184,7 +182,7 @@ class Layout(Generic[_K]):
         return x + 1
 
     def _add_connected_graph(
-        self, xgraph: networkx.DiGraph | networkx.MultiDiGraph, order: list[_K] | None = None
+        self, xgraph: networkx.DiGraph | networkx.MultiDiGraph, order: list[K] | None = None
     ) -> None:
         """Add a subgraph whose nodes are connected.
 
@@ -202,7 +200,7 @@ class Layout(Generic[_K]):
         # "backbone" of our layout; we'll step through this path and add
         # recurse via calls to `_add_graph` on the nodes that we think should
         # go between the backbone nodes.
-        backbone: list[_K] = networkx.algorithms.dag.dag_longest_path(xgraph, topo_order=order)
+        backbone: list[K] = networkx.algorithms.dag.dag_longest_path(xgraph, topo_order=order)
         # Add the first backbone node and any ancestors according to the full
         # graph (it can't have ancestors in this _subgraph_ because they'd have
         # been part of the longest path themselves, but the subgraph doesn't
@@ -237,7 +235,7 @@ class Layout(Generic[_K]):
         remaining.remove_nodes_from(self._locations.keys())
         self._add_graph(remaining)
 
-    def _add_blockers_of(self, node: _K) -> None:
+    def _add_blockers_of(self, node: K) -> None:
         """Add all nodes that are ancestors of the given node according to the
         full graph.
         """
@@ -251,7 +249,7 @@ class Layout(Generic[_K]):
         return (self._x_max - self._x_min) // 2
 
     @property
-    def nodes(self) -> Iterable[_K]:
+    def nodes(self) -> Iterable[K]:
         """The graph nodes in the order they appear in the layout."""
         return self._locations.keys()
 
@@ -277,7 +275,7 @@ class Layout(Generic[_K]):
         return (self._x_max - x) // 2
 
     def __iter__(self) -> Iterator[LayoutRow]:
-        active_edges: dict[_K, set[_K]] = {}
+        active_edges: dict[K, set[K]] = {}
         for node, node_x in self._locations.items():
             row = LayoutRow(node, self._external_location(node_x))
             for origin, destinations in active_edges.items():
@@ -295,20 +293,20 @@ class Layout(Generic[_K]):
 
 
 @dataclasses.dataclass
-class LayoutRow(Generic[_K]):
+class LayoutRow[K]:
     """Information about a single text-art row in a graph."""
 
-    node: _K
+    node: K
     """Key for the node in the exported NetworkX graph."""
 
     x: int
     """Column of the node's symbol and its outgoing edges."""
 
-    connecting: list[tuple[int, _K]] = dataclasses.field(default_factory=list)
+    connecting: list[tuple[int, K]] = dataclasses.field(default_factory=list)
     """The columns and node keys of edges that terminate at this row.
     """
 
-    continuing: list[tuple[int, _K, frozenset[_K]]] = dataclasses.field(default_factory=list)
+    continuing: list[tuple[int, K, frozenset[K]]] = dataclasses.field(default_factory=list)
     """The columns and node keys of edges that continue through this row.
     """
 
@@ -337,11 +335,11 @@ class ColumnSelector:
     out in that case because it's applied to all candidate columns.
     """
 
-    def __call__(
+    def __call__[K](
         self,
         connecting_x: list[int],
         node_x: int,
-        active_columns: Mapping[int, Set[_K]],
+        active_columns: Mapping[int, Set[K]],
         x_min: int,
         x_max: int,
     ) -> int:

lsst/pipe/base/pipeline_graph/visualization/_merge.py

@@ -38,7 +38,7 @@ import hashlib
 from collections import defaultdict
 from collections.abc import Iterable
 from functools import cached_property
-from typing import Any, TypeVar
+from typing import Any
 
 import networkx
 import networkx.algorithms.dag
@@ -49,9 +49,6 @@ from lsst.daf.butler import DimensionGroup
 from .._nodes import NodeKey, NodeType
 from ._options import NodeAttributeOptions
 
-_P = TypeVar("_P")
-_C = TypeVar("_C")
-
 
 class MergedNodeKey(frozenset[NodeKey]):
     """A key for NetworkX graph nodes that represent multiple similar tasks
@@ -225,11 +222,11 @@ class _MergeKey:
     """
 
     @classmethod
-    def from_node_state(
+    def from_node_state[P, C](
         cls,
         state: dict[str, Any],
-        parents: Iterable[_P],
-        children: Iterable[_C],
+        parents: Iterable[P],
+        children: Iterable[C],
         options: NodeAttributeOptions,
     ) -> _MergeKey:
         """Construct from a NetworkX node attribute state dictionary.

lsst/pipe/base/pipeline_graph/visualization/_printer.py

@@ -30,9 +30,9 @@ __all__ = ("Printer", "make_colorama_printer", "make_default_printer", "make_sim
 
 import sys
 from collections.abc import Callable, Sequence
-from typing import Generic, TextIO
+from typing import TextIO
 
-from ._layout import _K, Layout, LayoutRow
+from ._layout import Layout, LayoutRow
 
 _CHAR_DECOMPOSITION = {
     # This mapping provides the "logic" for how to decompose the relevant
@@ -170,7 +170,7 @@ class PrintRow:
         return "".join(self._cells)
 
 
-def _default_get_text(node: _K, x: int, style: tuple[str, str]) -> str:
+def _default_get_text[K](node: K, x: int, style: tuple[str, str]) -> str:
     """Return the default text to associate with a node.
 
     This function is the default value for the ``get_text`` argument to
@@ -179,7 +179,7 @@ def _default_get_text(node: _K, x: int, style: tuple[str, str]) -> str:
     return str(node)
 
 
-def _default_get_symbol(node: _K, x: int) -> str:
+def _default_get_symbol[K](node: K, x: int) -> str:
     """Return the default symbol for a node.
 
     This function is the default value for the ``get_symbol`` argument to
@@ -188,7 +188,7 @@ def _default_get_symbol(node: _K, x: int) -> str:
     return "⬤"
 
 
-def _default_get_style(node: _K, x: int) -> tuple[str, str]:
+def _default_get_style[K](node: K, x: int) -> tuple[str, str]:
     """Get the default styling suffix/prefix strings.
 
     This function is the default value for the ``get_style`` argument to
@@ -197,7 +197,7 @@ def _default_get_style(node: _K, x: int) -> tuple[str, str]:
     return "", ""
 
 
-class Printer(Generic[_K]):
+class Printer[K]:
     """High-level tool for drawing a text-based DAG visualization.
 
     Parameters
@@ -231,9 +231,9 @@ class Printer(Generic[_K]):
         *,
         pad: str = " ",
         make_blank_row: Callable[[int, str], PrintRow] = PrintRow,
-        get_text: Callable[[_K, int, tuple[str, str]], str] = _default_get_text,
-        get_symbol: Callable[[_K, int], str] = _default_get_symbol,
-        get_style: Callable[[_K, int], tuple[str, str]] = _default_get_style,
+        get_text: Callable[[K, int, tuple[str, str]], str] = _default_get_text,
+        get_symbol: Callable[[K, int], str] = _default_get_symbol,
+        get_style: Callable[[K, int], tuple[str, str]] = _default_get_style,
     ):
         self.width = layout_width * 2 + 1
         self.pad = pad
@@ -245,7 +245,7 @@ class Printer(Generic[_K]):
     def print_row(
         self,
         stream: TextIO,
-        layout_row: LayoutRow[_K],
+        layout_row: LayoutRow[K],
     ) -> None:
         """Print a single row of the DAG visualization to a file-like object.
 

lsst/pipe/base/pipeline_graph/visualization/_status_annotator.py

@@ -200,6 +200,13 @@ class QuantumGraphExecutionStatusAnnotator:
     """Annotates a networkx graph with task and dataset status information from
     a quantum graph execution summary, implementing the StatusAnnotator
     protocol to update the graph with status data.
+
+    Parameters
+    ----------
+    *args : `typing.Any`
+        Arbitrary arguments.
+    **kwargs : `typing.Any`
+        Arbitrary keyword arguments.
     """
 
     def __init__(self, *args: Any, **kwargs: Any) -> None:

lsst/pipe/base/prerequisite_helpers.py

@@ -252,7 +252,8 @@ class PrerequisiteFinder:
             Sequence of collections to search, in order.
         data_id : `lsst.daf.butler.DataCoordinate`
             Data ID for the quantum.
-        skypix_bounds : `Mapping` [ `str`, `lsst.sphgeom.RangeSet` ]
+        skypix_bounds : `~collections.abc.Mapping` \
+              [ `str`, `lsst.sphgeom.RangeSet` ]
             The spatial bounds of this quantum in various skypix dimensions.
             Keys are skypix dimension names (a superset of those in
             `dataset_skypix`) and values are sets of integer pixel ID ranges.