Make opset_imports required in build_graph and build_function

Remove the default of {"":23} — callers must explicitly specify
opset_imports. This avoids silent version assumptions.
subgraph() is unchanged since it inherits from the parent graph.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Signed-off-by: G Ramalingam <grama@microsoft.com>

Author: gramalingam

onnxscript/_internal/builder.py

@@ -230,7 +230,7 @@ def build_graph(
     inputs: Sequence[ir.Value | None],
     outputs: Sequence[ir.Value],
     *,
-    opset_imports: dict[str, int] | None = None,
+    opset_imports: dict[str, int],
     name: str = "subgraph",
     parent: GraphBuilder | None = None,
 ) -> ir.Graph:
@@ -246,6 +246,7 @@ def build_graph(
             lambda op, x, y: op.Add(x, y),
             inputs=[make_value("x", FLOAT[3, 4]), make_value("y", FLOAT[3, 4])],
             outputs=[make_value("sum", FLOAT[3, 4])],
+            opset_imports={"": 23},
         )
 
     Args:
@@ -263,7 +264,7 @@ def build_graph(
             the expected outputs.  After tracing, the name and type of each
             declared output are applied to the corresponding returned value.
         opset_imports: Opset version map for the subgraph (e.g.
-            ``{"": 23}``).  Defaults to ``{"": 23}`` when *None*.
+            ``{"": 23}``).
         name: Name of the resulting :class:`ir.Graph`.
         parent: Optional parent :class:`GraphBuilder`.  When provided, the
             sub-builder's ``_root`` points to the root builder of the parent,
@@ -276,9 +277,6 @@ def build_graph(
         passed directly as a graph-valued attribute (e.g. the ``body`` attribute of
         a ``Scan`` or ``Loop`` node).
     """
-    if opset_imports is None:
-        opset_imports = {"": 23}
-
     trace_args, graph_inputs = _split_optional_inputs(inputs)
 
     subgraph = ir.Graph(
@@ -325,7 +323,7 @@ def build_function(
     domain: str,
     name: str,
     attributes: Mapping[str, ir.Attr] | Sequence[ir.Attr] | None = None,
-    opset_imports: dict[str, int] | None = None,
+    opset_imports: dict[str, int],
 ) -> ir.Function:
     """Build an :class:`ir.Function` by tracing *trace_function*.
 
@@ -340,6 +338,7 @@ def build_function(
             [make_value("x"), make_value("y")],
             domain="com.example",
             name="MyAdd",
+            opset_imports={"": 23},
         )
 
     Args:
@@ -358,15 +357,12 @@ def build_function(
         attributes: Function-level attributes.  Accepts a
             :class:`Mapping` from name to :class:`ir.Attr`, a
             :class:`Sequence` of :class:`ir.Attr`, or ``None``.
-        opset_imports: Opset version map.  Defaults to ``{"": 23}``.
+        opset_imports: Opset version map (e.g. ``{"": 23}``).
 
     Returns:
         An :class:`ir.Function` with initializers automatically lifted to
         ``Constant`` nodes.
     """
-    if opset_imports is None:
-        opset_imports = {"": 23}
-
     trace_args, graph_inputs = _split_optional_inputs(inputs)
 
     graph = ir.Graph(

onnxscript/_internal/builder_test.py

@@ -15,6 +15,7 @@
 from onnxscript.onnx_types import DOUBLE, FLOAT, INT64
 
 _default_opset_version = 23
+_opset = {"": _default_opset_version}
 
 # Convenience alias for tests — creates an ir.Value from (name, TypeSpec).
 _input = builder.make_value
@@ -1238,6 +1239,7 @@ def test_build_graph_custom_name(self):
             inputs=[_input("x", FLOAT[...])],
             outputs=[_input("y", FLOAT[...])],
             name="loop_body",
+            opset_imports=_opset,
         )
         self.assertEqual(graph.name, "loop_body")
 
@@ -1262,6 +1264,7 @@ def body(op, x):
             inputs=[_input("x", FLOAT[3])],
             outputs=[_input("y", FLOAT[3])],
             parent=parent_builder,
+            opset_imports=_opset,
         )
 
     def test_subgraph_sets_parent_and_root(self):
@@ -1304,8 +1307,8 @@ def test_build_graph_inherits_parent_scope_stack(self):
             inputs=[_input("x", FLOAT[3, 4])],
             outputs=[_input("y", FLOAT[3, 4])],
             parent=parent_builder,
+            opset_imports=_opset,
         )
-
         # The single node created inside the subgraph should carry the
         # parent's scope prefix in its name and metadata.
         node = subgraph.node(0)
@@ -1685,6 +1688,7 @@ def test_build_function_basic(self):
             [_input("x", FLOAT[3, 4]), _input("y", FLOAT[3, 4])],
             domain="com.test",
             name="MyAdd",
+            opset_imports=_opset,
         )
         self.assertIsInstance(fn, ir.Function)
         self.assertEqual(fn.domain, "com.test")
@@ -1705,6 +1709,7 @@ def body(op, x, y):
             [_input("x"), _input("y")],
             domain="com.test",
             name="AddAndMul",
+            opset_imports=_opset,
         )
         self.assertEqual(len(fn.graph.outputs), 2)
 
@@ -1719,6 +1724,7 @@ def test_build_function_with_attributes(self):
                 ir.Attr("scale", ir.AttributeType.FLOAT, 0.5),
                 ir.Attr("mode", ir.AttributeType.STRING, "fast"),
             ],
+            opset_imports=_opset,
         )
         self.assertIn("scale", fn.attributes)
         self.assertIn("mode", fn.attributes)
@@ -1732,6 +1738,7 @@ def test_build_function_attributes_as_dict(self):
             domain="com.test",
             name="DictAttr",
             attributes={"scale": attr},
+            opset_imports=_opset,
         )
         self.assertIn("scale", fn.attributes)
 
@@ -1742,6 +1749,7 @@ def test_build_function_lifts_initializers(self):
             [_input("x", FLOAT[3])],
             domain="com.test",
             name="WithLiteral",
+            opset_imports=_opset,
         )
         # No initializers in function body
         self.assertEqual(len(fn.graph.initializers), 0)
@@ -1763,6 +1771,7 @@ def body(op, x, y, z):
             [_input("x", FLOAT[3]), None, _input("z", FLOAT[3])],
             domain="com.test",
             name="OptionalInputs",
+            opset_imports=_opset,
         )
         # Graph has 3 inputs: x, a placeholder for the absent y, and z
         self.assertEqual(len(fn.graph.inputs), 3)
@@ -1785,6 +1794,7 @@ def body(op, x):
             [_input("x")],
             domain="com.test",
             name="AppendOutputs",
+            opset_imports=_opset,
         )
         self.assertEqual(len(fn.graph.outputs), 1)
         self.assertEqual(fn.graph.outputs[0].name, "result")
@@ -1803,6 +1813,7 @@ def body(op, x):
                 [_input("x")],
                 domain="com.test",
                 name="MixedOutputs",
+            opset_imports=_opset,
             )
 
     def test_build_function_no_outputs_raises(self):
@@ -1818,6 +1829,7 @@ def body(op, x):
                 [_input("x")],
                 domain="com.test",
                 name="NoOutputs",
+            opset_imports=_opset,
             )
 
     def test_build_function_input_with_producer_raises(self):
@@ -1832,6 +1844,7 @@ def test_build_function_input_with_producer_raises(self):
                 [used_value],
                 domain="com.test",
                 name="BadInput",
+            opset_imports=_opset,
             )
 
     def test_build_function_custom_opset(self):
@@ -1852,6 +1865,7 @@ def test_build_function_no_parent_isolation(self):
             [_input("x", FLOAT[3])],
             domain="com.test",
             name="Isolated",
+            opset_imports=_opset,
         )
         # After lifting, there should be a Constant node and no initializers
         self.assertEqual(len(fn.graph.initializers), 0)

onnxscript/nn/_module_test.py

@@ -131,6 +131,7 @@ def outer_fn(op, x):
                 inputs=[make_value("x", FLOAT[3])],
                 outputs=[make_value("y", FLOAT[3])],
                 parent=op.builder,
+                opset_imports={"": 23},
             )
             return op.Identity(x)