lsst-pipe-base 30.0.1rc1__py3-none-any.whl → 30.2025.5200__py3-none-any.whl

lsst/pipe/base/mp_graph_executor.py

@@ -39,24 +39,20 @@ import sys
 import threading
 import time
 import uuid
-from contextlib import ExitStack
 from typing import Literal, cast
 
 import networkx
 
 from lsst.daf.butler import DataCoordinate, Quantum
 from lsst.daf.butler.cli.cliLog import CliLog
-from lsst.daf.butler.logging import ButlerLogRecords
 from lsst.utils.threads import disable_implicit_threading
 
 from ._status import InvalidQuantumError, RepeatableQuantumError
-from ._task_metadata import TaskMetadata
 from .execution_graph_fixup import ExecutionGraphFixup
 from .graph import QuantumGraph
 from .graph_walker import GraphWalker
-from .log_on_close import LogOnClose
 from .pipeline_graph import TaskNode
-from .quantum_graph import PredictedQuantumGraph, PredictedQuantumInfo, ProvenanceQuantumGraphWriter
+from .quantum_graph import PredictedQuantumGraph, PredictedQuantumInfo
 from .quantum_graph_executor import QuantumExecutor, QuantumGraphExecutor
 from .quantum_reports import ExecutionStatus, QuantumReport, Report
 
@@ -519,9 +515,7 @@ class MPGraphExecutor(QuantumGraphExecutor):
             start_method = "spawn"
         self._start_method = start_method
 
-    def execute(
-        self, graph: QuantumGraph | PredictedQuantumGraph, *, provenance_graph_file: str | None = None
-    ) -> None:
+    def execute(self, graph: QuantumGraph | PredictedQuantumGraph) -> None:
         # Docstring inherited from QuantumGraphExecutor.execute
         old_graph: QuantumGraph | None = None
         if isinstance(graph, QuantumGraph):
@@ -531,31 +525,14 @@ class MPGraphExecutor(QuantumGraphExecutor):
             new_graph = graph
         xgraph = self._make_xgraph(new_graph, old_graph)
         self._report = Report(qgraphSummary=new_graph._make_summary())
-        with ExitStack() as exit_stack:
-            provenance_writer: ProvenanceQuantumGraphWriter | None = None
-            if provenance_graph_file is not None:
-                if provenance_graph_file is not None and self._num_proc > 1:
-                    raise NotImplementedError(
-                        "Provenance writing is not implemented for multiprocess execution."
-                    )
-                provenance_writer = ProvenanceQuantumGraphWriter(
-                    provenance_graph_file,
-                    exit_stack=exit_stack,
-                    log_on_close=LogOnClose(_LOG.log),
-                    predicted=new_graph,
-                )
-            try:
-                if self._num_proc > 1:
-                    self._execute_quanta_mp(xgraph, self._report)
-                else:
-                    self._execute_quanta_in_process(xgraph, self._report, provenance_writer)
-            except Exception as exc:
-                self._report.set_exception(exc)
-                raise
-            if provenance_writer is not None:
-                provenance_writer.write_overall_inputs()
-                provenance_writer.write_packages()
-                provenance_writer.write_init_outputs(assume_existence=True)
+        try:
+            if self._num_proc > 1:
+                self._execute_quanta_mp(xgraph, self._report)
+            else:
+                self._execute_quanta_in_process(xgraph, self._report)
+        except Exception as exc:
+            self._report.set_exception(exc)
+            raise
 
     def _make_xgraph(
         self, new_graph: PredictedQuantumGraph, old_graph: QuantumGraph | None
@@ -599,9 +576,7 @@ class MPGraphExecutor(QuantumGraphExecutor):
                 raise MPGraphExecutorError("Updated execution graph has dependency cycle.")
         return xgraph
 
-    def _execute_quanta_in_process(
-        self, xgraph: networkx.DiGraph, report: Report, provenance_writer: ProvenanceQuantumGraphWriter | None
-    ) -> None:
+    def _execute_quanta_in_process(self, xgraph: networkx.DiGraph, report: Report) -> None:
         """Execute all Quanta in current process.
 
         Parameters
@@ -614,9 +589,6 @@ class MPGraphExecutor(QuantumGraphExecutor):
             `.quantum_graph.PredictedQuantumGraph.quantum_only_xgraph`.
         report : `Report`
             Object for reporting execution status.
-        provenance_writer : `.quantum_graph.ProvenanceQuantumGraphWriter` or \
-                `None`
-            Object for recording provenance.
         """
 
         def tiebreaker_sort_key(quantum_id: uuid.UUID) -> tuple:
@@ -634,19 +606,16 @@ class MPGraphExecutor(QuantumGraphExecutor):
 
                 _LOG.debug("Executing %s (%s@%s)", quantum_id, task_node.label, data_id)
                 fail_exit_code: int | None = None
-                task_metadata: TaskMetadata | None = None
-                task_logs = ButlerLogRecords([])
                 try:
                     # For some exception types we want to exit immediately with
                     # exception-specific exit code, but we still want to start
                     # debugger before exiting if debugging is enabled.
                     try:
-                        execution_result = self._quantum_executor.execute(
-                            task_node, quantum, quantum_id=quantum_id, log_records=task_logs
+                        _, quantum_report = self._quantum_executor.execute(
+                            task_node, quantum, quantum_id=quantum_id
                         )
-                        if execution_result.report:
-                            report.quantaReports.append(execution_result.report)
-                        task_metadata = execution_result.task_metadata
+                        if quantum_report:
+                            report.quantaReports.append(quantum_report)
                         success_count += 1
                         walker.finish(quantum_id)
                     except RepeatableQuantumError as exc:
@@ -732,11 +701,6 @@ class MPGraphExecutor(QuantumGraphExecutor):
                         )
                         failed_count += 1
 
-                if provenance_writer is not None:
-                    provenance_writer.write_quantum_provenance(
-                        quantum_id, metadata=task_metadata, logs=task_logs
-                    )
-
                 _LOG.info(
                     "Executed %d quanta successfully, %d failed and %d remain out of total %d quanta.",
                     success_count,

lsst/pipe/base/pipeline.py

@@ -54,12 +54,13 @@ from lsst.utils.introspection import get_full_type_name
 
 from . import automatic_connection_constants as acc
 from . import pipeline_graph, pipelineIR
-from ._instrument import Instrument as Instrument
+from ._instrument import Instrument as PipeBaseInstrument
 from .config import PipelineTaskConfig
 from .connections import PipelineTaskConnections
 from .pipelineTask import PipelineTask
 
 if TYPE_CHECKING:  # Imports needed only for type annotations; may be circular.
+    from lsst.obs.base import Instrument
     from lsst.pex.config import Config
 
 # ----------------------------------
@@ -495,7 +496,7 @@ class Pipeline:
         Returns
         -------
         pipeline: `Pipeline`
-            The new pipeline.
+           The new pipeline.
         """
         return cls.fromIR(copy.deepcopy(pipeline._pipelineIR))
 
@@ -605,7 +606,7 @@ class Pipeline:
 
     @property
     def subsets(self) -> MappingProxyType[str, set]:
-        """Returns a `types.MappingProxyType` where the keys are the labels of
+        """Returns a `MappingProxyType` where the keys are the labels of
         labeled subsets in the `Pipeline` and the values are the set of task
         labels contained within that subset.
         """
@@ -701,7 +702,7 @@ class Pipeline:
         """
         instrument_class_name = self._pipelineIR.instrument
         if instrument_class_name is not None:
-            instrument_class = cast(Instrument, doImportType(instrument_class_name))
+            instrument_class = cast(PipeBaseInstrument, doImportType(instrument_class_name))
             if instrument_class is not None:
                 return DataCoordinate.standardize(instrument=instrument_class.getName(), universe=universe)
         return DataCoordinate.make_empty(universe)
@@ -892,7 +893,7 @@ class Pipeline:
             raise NameError(f"Label {label} does not appear in this pipeline")
         taskClass: type[PipelineTask] = doImportType(taskIR.klass)
         config = taskClass.ConfigClass()
-        instrument: Instrument | None = None
+        instrument: PipeBaseInstrument | None = None
         if (instrumentName := self._pipelineIR.instrument) is not None:
             instrument_cls: type = doImportType(instrumentName)
             instrument = instrument_cls()

lsst/pipe/base/pipelineIR.py

@@ -220,6 +220,12 @@ class LabeledSubset:
 class ParametersIR:
     """Intermediate representation of parameters that are global to a pipeline.
 
+    Attributes
+    ----------
+    mapping : `dict` [`str`, `str`]
+        A mutable mapping of identifiers as keys, and shared configuration
+        as values.
+
     Notes
     -----
     These parameters are specified under a top level key named ``parameters``
@@ -337,7 +343,7 @@ class ConfigIR:
                 )
         return new_config
 
-    def maybe_merge(self, other_config: ConfigIR) -> Generator[ConfigIR]:
+    def maybe_merge(self, other_config: ConfigIR) -> Generator[ConfigIR, None, None]:
         """Merge another instance of a `ConfigIR` into this instance if
         possible. This function returns a generator that is either self
         if the configs were merged, or self, and other_config if that could
@@ -700,7 +706,7 @@ class PipelineIR:
 
         Parameters
         ----------
-        loaded_yaml : `dict`
+        loaded_yaml: `dict`
             A dictionary which matches the structure that would be produced
             by a yaml reader which parses a pipeline definition document
         """

lsst/pipe/base/pipelineTask.py

@@ -55,7 +55,7 @@ class PipelineTask(Task):
     resulting data is also stored in a data butler.
 
     PipelineTask inherits from a `~lsst.pipe.base.Task` and uses the same
-    configuration mechanism based on `lsst.pex.config`. `PipelineTask`
+    configuration mechanism based on :ref:`lsst.pex.config`. `PipelineTask`
     classes also have a `PipelineTaskConnections` class associated with their
     config which defines all of the IO a `PipelineTask` will need to do.
     PipelineTask sub-class typically implements `run()` method which receives
@@ -75,6 +75,12 @@ class PipelineTask(Task):
     PipelineTask base class constructor, but may support other signatures as
     well.
 
+    Attributes
+    ----------
+    canMultiprocess : bool, True by default (class attribute)
+        This class attribute is checked by execution framework, sub-classes
+        can set it to ``False`` in case task does not support multiprocessing.
+
     Parameters
     ----------
     config : `~lsst.pex.config.Config`, optional
@@ -96,11 +102,7 @@ class PipelineTask(Task):
     """
 
     ConfigClass: ClassVar[type[PipelineTaskConfig]]
-
     canMultiprocess: ClassVar[bool] = True
-    """Whether this task can be run by an executor that uses subprocesses for
-    parallelism.
-    """
 
     def __init__(
         self,

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
-            `~lsst.daf.butler.DatasetType` registered in the data repository,
-            or `None` if it is not registered.
+            `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
+from typing import Any, ClassVar, Self, TypeVar
 
 from lsst.daf.butler import DatasetRef, DatasetType, DimensionUniverse, StorageClassFactory
 from lsst.daf.butler.registry import MissingDatasetTypeError
@@ -40,6 +40,8 @@ from ..connectionTypes import BaseConnection
 from ._exceptions import ConnectionTypeConsistencyError, IncompatibleDatasetTypeError
 from ._nodes import NodeKey, NodeType
 
+_S = TypeVar("_S", bound="Edge")
+
 
 @immutable
 class Edge(ABC):
@@ -170,7 +172,7 @@ class Edge(ABC):
         """
         return self.parent_dataset_type_name
 
-    def diff[S: Edge](self: S, other: S, connection_type: str = "connection") -> list[str]:
+    def diff(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.
 
@@ -478,11 +480,11 @@ class ReadEdge(Edge):
         Parameters
         ----------
         current : `lsst.daf.butler.DatasetType` or `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`.
+            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`.
         is_initial_query_constraint : `bool`
             Whether this dataset type is currently marked as a constraint on
             the initial data ID query in QuantumGraph generation.
@@ -494,7 +496,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 : `~collections.abc.Sequence` [ `str` ]
+        consumers : `Sequence` [ `str` ]
             Labels for other consuming tasks that have already participated in
             this dataset type's resolution.
         is_registered : `bool`
@@ -510,7 +512,7 @@ class ReadEdge(Edge):
 
         Returns
         -------
-        dataset_type : `~lsst.daf.butler.DatasetType`
+        dataset_type : `DatasetType`
             The updated graph-wide dataset type.  If ``current`` was provided,
             this must be equal to it.
         is_initial_query_constraint : `bool`
@@ -657,25 +659,13 @@ class ReadEdge(Edge):
                     # compatible), since neither connection should take
                     # precedence.
                     if dataset_type != current:
-                        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."
-                            )
+                        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."
+                        )
                 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}; "
@@ -798,15 +788,15 @@ class WriteEdge(Edge):
         Parameters
         ----------
         current : `lsst.daf.butler.DatasetType` or `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.
+            The current graph-wide `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 : `~lsst.daf.butler.DatasetType`
+        dataset_type : `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, cast, overload
+from typing import Any, ClassVar, TypeVar, cast, overload
 
 import networkx
 
@@ -36,8 +36,11 @@ from ._exceptions import UnresolvedGraphError
 from ._nodes import NodeKey, NodeType
 from ._tasks import TaskInitNode, TaskNode
 
+_N = TypeVar("_N", covariant=True)
+_T = TypeVar("_T")
 
-class MappingView[N](Mapping[str, N]):
+
+class MappingView(Mapping[str, _N]):
     """Base class for mapping views into nodes of certain types in a
     `PipelineGraph`.
 
@@ -71,7 +74,7 @@ class MappingView[N](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:
@@ -227,7 +230,7 @@ class DatasetTypeMappingView(MappingView[DatasetTypeNode]):
     def get_if_resolved(self, key: str) -> DatasetTypeNode | None: ...  # pragma: nocover
 
     @overload
-    def get_if_resolved[T](self, key: str, default: T) -> DatasetTypeNode | T: ...  # pragma: nocover
+    def get_if_resolved(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, cast
+from typing import TYPE_CHECKING, Any, BinaryIO, Literal, TypeVar, cast
 
 import networkx
 import networkx.algorithms.bipartite
@@ -79,6 +79,9 @@ 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")
 
 
@@ -894,10 +897,6 @@ 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
@@ -1633,7 +1632,7 @@ class PipelineGraph:
 
         Returns
         -------
-        subgraphs : `~collections.abc.Iterable` [ `PipelineGraph` ]
+        subgraphs : `Iterable` [ `PipelineGraph` ]
             An iterable over component subgraphs that could be run
             independently (they have only overall inputs in common).  May be a
             lazy iterator.
@@ -1756,10 +1755,6 @@ 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
@@ -2184,9 +2179,7 @@ class PipelineGraph:
         ]
         return networkx.algorithms.bipartite.projected_graph(networkx.DiGraph(bipartite_xgraph), task_keys)
 
-    def _transform_xgraph_state[G: networkx.DiGraph | networkx.MultiDiGraph](
-        self, xgraph: G, skip_edges: bool
-    ) -> G:
+    def _transform_xgraph_state(self, xgraph: _G, skip_edges: bool) -> _G:
         """Transform networkx graph attributes in-place from the internal
         "instance" attributes to the documented exported attributes.
 
@@ -2235,7 +2228,7 @@ class PipelineGraph:
 
         Parameters
         ----------
-        updates : `~collections.abc.Mapping` [ `str`, `TaskNode` ]
+        updates : `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
+from typing import TYPE_CHECKING, Any, Literal, TypeAlias
 
 from lsst.daf.butler.queries.expressions.parser.ply import lex, yacc
 
@@ -268,4 +268,4 @@ def parse(expression: str) -> Node:
     return _ParserYacc().parse(expression)
 
 
-type Node = IdentifierNode | DirectionNode | NotNode | UnionNode | IntersectionNode
+Node: TypeAlias = IdentifierNode | DirectionNode | NotNode | UnionNode | IntersectionNode

lsst/pipe/base/pipeline_graph/io.py

@@ -33,10 +33,11 @@ __all__ = (
     "SerializedTaskInitNode",
     "SerializedTaskNode",
     "SerializedTaskSubset",
+    "expect_not_none",
 )
 
 from collections.abc import Mapping
-from typing import Any
+from typing import Any, TypeVar
 
 import networkx
 import pydantic
@@ -52,12 +53,14 @@ 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[U](value: U | None, msg: str) -> U:
+def expect_not_none(value: _U | None, msg: str) -> _U:
     """Check that a value is not `None` and return it.
 
     Parameters
@@ -415,7 +418,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,
@@ -544,16 +547,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.",
@@ -744,7 +747,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 : `io.TextIO`, optional
+    stream : `TextIO`, optional
         Stream to write the DOT representation to.
     label_edge_connections : `bool`, optional
         If `True`, label edges with their connection names.
@@ -167,22 +167,21 @@ def _render_dataset_type_node(
 
     Parameters
     ----------
-    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
+    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
 
     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:
@@ -272,7 +271,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: