Rename GraphDef -> GraphDefinition and Condition -> GraphCondition (#1984)

Spell out abbreviations for consistency with the rest of cuda.core (#1950)
and add the Graph* prefix to Condition for consistency with GraphBuilder
/ GraphDefinition / GraphNode (#1945).

Source file _graph_def.{pyx,pxd} and test files test_graphdef*.py renamed
to match. 0.7.0 release notes converted to literal inline-code form for
the old GraphDef name so :class: cross-references resolve cleanly in
1.0.0+ doc builds without rewriting historical claims.

Made-with: Cursor

Author: Andy-Jost

cuda_core/cuda/core/__init__.py

@@ -63,11 +63,11 @@ def _import_versioned_module():
 )
 from cuda.core._tensor_map import TensorMapDescriptor, TensorMapDescriptorOptions
 from cuda.core.graph import (
-    Condition,
     Graph,
     GraphAllocOptions,
     GraphBuilder,
     GraphCompleteOptions,
+    GraphCondition,
     GraphDebugPrintOptions,
-    GraphDef,
+    GraphDefinition,
 )

cuda_core/cuda/core/graph/__init__.pxd

@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from cuda.core.graph._graph_def cimport Condition, GraphDef
+from cuda.core.graph._graph_definition cimport GraphCondition, GraphDefinition
 from cuda.core.graph._graph_node cimport GraphNode
 from cuda.core.graph._subclasses cimport (
     AllocNode,

cuda_core/cuda/core/graph/__init__.py

@@ -8,10 +8,10 @@
     GraphCompleteOptions,
     GraphDebugPrintOptions,
 )
-from cuda.core.graph._graph_def import (
-    Condition,
+from cuda.core.graph._graph_definition import (
     GraphAllocOptions,
-    GraphDef,
+    GraphCondition,
+    GraphDefinition,
 )
 from cuda.core.graph._graph_node import GraphNode
 from cuda.core.graph._subclasses import (

cuda_core/cuda/core/graph/_graph_builder.pyx

@@ -786,19 +786,19 @@ class Graph:
         """
         return self._mnff.graph
 
-    def update(self, source: "GraphBuilder | GraphDef") -> None:
+    def update(self, source: "GraphBuilder | GraphDefinition") -> None:
         """Update the graph using a new graph definition.
 
         The topology of the provided source must be identical to this graph.
 
         Parameters
         ----------
-        source : :obj:`~graph.GraphBuilder` or :obj:`~graph.GraphDef`
+        source : :obj:`~graph.GraphBuilder` or :obj:`~graph.GraphDefinition`
             The graph definition to update from. A GraphBuilder must have
             finished building.
 
         """
-        from cuda.core.graph import GraphDef
+        from cuda.core.graph import GraphDefinition
 
         cdef cydriver.CUgraph cu_graph
         cdef cydriver.CUgraphExec cu_exec = <cydriver.CUgraphExec><intptr_t>int(self._mnff.graph)
@@ -807,11 +807,11 @@ class Graph:
             if not source._building_ended:
                 raise ValueError("Graph has not finished building.")
             cu_graph = <cydriver.CUgraph><intptr_t>int(source._mnff.graph)
-        elif isinstance(source, GraphDef):
+        elif isinstance(source, GraphDefinition):
             cu_graph = <cydriver.CUgraph><intptr_t>int(source.handle)
         else:
             raise TypeError(
-                f"expected GraphBuilder or GraphDef, got {type(source).__name__}")
+                f"expected GraphBuilder or GraphDefinition, got {type(source).__name__}")
 
         cdef cydriver.CUgraphExecUpdateResultInfo result_info
         cdef cydriver.CUresult err

cuda_core/cuda/core/graph/_graph_def.pxd …re/cuda/core/graph/_graph_definition.pxdcuda_core/cuda/core/graph/_graph_def.pxd renamed to cuda_core/cuda/core/graph/_graph_definition.pxd cuda_core/cuda/core/graph/_graph_def.pxd renamed to cuda_core/cuda/core/graph/_graph_definition.pxd

@@ -6,16 +6,16 @@ from cuda.bindings cimport cydriver
 from cuda.core._resource_handles cimport GraphHandle
 
 
-cdef class Condition:
+cdef class GraphCondition:
     cdef:
         cydriver.CUgraphConditionalHandle _c_handle
         object __weakref__
 
 
-cdef class GraphDef:
+cdef class GraphDefinition:
     cdef:
         GraphHandle _h_graph
         object __weakref__
 
     @staticmethod
-    cdef GraphDef _from_handle(GraphHandle h_graph)
+    cdef GraphDefinition _from_handle(GraphHandle h_graph)

cuda_core/cuda/core/graph/_graph_def.pyx …re/cuda/core/graph/_graph_definition.pyxcuda_core/cuda/core/graph/_graph_def.pyx renamed to cuda_core/cuda/core/graph/_graph_definition.pyx cuda_core/cuda/core/graph/_graph_def.pyx renamed to cuda_core/cuda/core/graph/_graph_definition.pyx

@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-"""GraphDef: explicit CUDA graph definition."""
+"""GraphDefinition: explicit CUDA graph definition."""
 
 from __future__ import annotations
 
@@ -28,22 +28,22 @@ from dataclasses import dataclass
 from cuda.core._utils.cuda_utils import driver
 
 
-cdef class Condition:
+cdef class GraphCondition:
     """A condition variable for conditional graph nodes.
 
-    Created by :meth:`GraphDef.create_condition` and passed to
+    Created by :meth:`GraphDefinition.create_condition` and passed to
     conditional-node builder methods (``if_cond``, ``if_else``,
     ``while_loop``, ``switch``). The underlying value is set at
     runtime by device code via ``cudaGraphSetConditional``.
     """
 
     def __repr__(self) -> str:
-        return f"<Condition handle=0x{<unsigned long long>self._c_handle:x}>"
+        return f"<GraphCondition handle=0x{<unsigned long long>self._c_handle:x}>"
 
     def __eq__(self, other) -> bool:
-        if not isinstance(other, Condition):
+        if not isinstance(other, GraphCondition):
             return NotImplemented
-        return self._c_handle == (<Condition>other)._c_handle
+        return self._c_handle == (<GraphCondition>other)._c_handle
 
     def __hash__(self) -> int:
         return hash(<unsigned long long>self._c_handle)
@@ -90,10 +90,10 @@ class GraphAllocOptions:
     peer_access: list | None = None
 
 
-cdef class GraphDef:
+cdef class GraphDefinition:
     """A graph definition.
 
-    A GraphDef is used to construct a graph explicitly by adding nodes
+    A GraphDefinition is used to construct a graph explicitly by adding nodes
     and specifying dependencies. Once construction is complete, call
     instantiate() to obtain an executable Graph.
     """
@@ -106,19 +106,19 @@ cdef class GraphDef:
         self._h_graph = create_graph_handle(graph)
 
     @staticmethod
-    cdef GraphDef _from_handle(GraphHandle h_graph):
-        """Create a GraphDef from an existing GraphHandle (internal use)."""
-        cdef GraphDef g = GraphDef.__new__(GraphDef)
+    cdef GraphDefinition _from_handle(GraphHandle h_graph):
+        """Create a GraphDefinition from an existing GraphHandle (internal use)."""
+        cdef GraphDefinition g = GraphDefinition.__new__(GraphDefinition)
         g._h_graph = h_graph
         return g
 
     def __repr__(self) -> str:
-        return f"<GraphDef handle=0x{as_intptr(self._h_graph):x}>"
+        return f"<GraphDefinition handle=0x{as_intptr(self._h_graph):x}>"
 
     def __eq__(self, other) -> bool:
-        if not isinstance(other, GraphDef):
+        if not isinstance(other, GraphDefinition):
             return NotImplemented
-        return as_intptr(self._h_graph) == as_intptr((<GraphDef>other)._h_graph)
+        return as_intptr(self._h_graph) == as_intptr((<GraphDefinition>other)._h_graph)
 
     def __hash__(self) -> int:
         return hash(as_intptr(self._h_graph))
@@ -190,7 +190,7 @@ cdef class GraphDef:
         """
         return self._entry.memcpy(dst, src, size)
 
-    def embed(self, child: GraphDef) -> "ChildGraphNode":
+    def embed(self, child: GraphDefinition) -> "ChildGraphNode":
         """Add an entry-point child graph node (no dependencies).
 
         See :meth:`GraphNode.embed` for full documentation.
@@ -218,10 +218,10 @@ cdef class GraphDef:
         """
         return self._entry.callback(fn, user_data=user_data)
 
-    def create_condition(self, default_value: int | None = None) -> Condition:
+    def create_condition(self, default_value: int | None = None) -> GraphCondition:
         """Create a condition variable for use with conditional nodes.
 
-        The returned :class:`Condition` object is passed to conditional-node
+        The returned :class:`GraphCondition` object is passed to conditional-node
         builder methods. Its value is controlled at runtime by device code
         via ``cudaGraphSetConditional``.
 
@@ -233,7 +233,7 @@ cdef class GraphDef:
 
         Returns
         -------
-        Condition
+        GraphCondition
             A condition variable for controlling conditional execution.
         """
         cdef cydriver.CUgraphConditionalHandle c_handle
@@ -250,32 +250,32 @@ cdef class GraphDef:
             HANDLE_RETURN(cydriver.cuGraphConditionalHandleCreate(
                 &c_handle, as_cu(self._h_graph), ctx, default_val, flags))
 
-        cdef Condition cond = Condition.__new__(Condition)
+        cdef GraphCondition cond = GraphCondition.__new__(GraphCondition)
         cond._c_handle = c_handle
         return cond
 
-    def if_cond(self, condition: Condition) -> "IfNode":
+    def if_cond(self, condition: GraphCondition) -> "IfNode":
         """Add an entry-point if-conditional node (no dependencies).
 
         See :meth:`GraphNode.if_cond` for full documentation.
         """
         return self._entry.if_cond(condition)
 
-    def if_else(self, condition: Condition) -> "IfElseNode":
+    def if_else(self, condition: GraphCondition) -> "IfElseNode":
         """Add an entry-point if-else conditional node (no dependencies).
 
         See :meth:`GraphNode.if_else` for full documentation.
         """
         return self._entry.if_else(condition)
 
-    def while_loop(self, condition: Condition) -> "WhileNode":
+    def while_loop(self, condition: GraphCondition) -> "WhileNode":
         """Add an entry-point while-loop conditional node (no dependencies).
 
         See :meth:`GraphNode.while_loop` for full documentation.
         """
         return self._entry.while_loop(condition)
 
-    def switch(self, condition: Condition, unsigned int count) -> "SwitchNode":
+    def switch(self, condition: GraphCondition, unsigned int count) -> "SwitchNode":
         """Add an entry-point switch conditional node (no dependencies).
 
         See :meth:`GraphNode.switch` for full documentation.