refactor: use '.' delimiter for value and node names

Change scope separator from '/' to '.' for value names, node names,
and namespace strings. The 'v_' prefix is now at the beginning of the
fully qualified value name (e.g. v_layer1.attention.Add_0).

Signed-off-by: Justin Chu <justinchuby@users.noreply.github.com>

Author: justinchuby

onnxscript/_internal/builder.py

@@ -374,29 +374,28 @@ def _qualify_initializer_name(self, name: str) -> str:
         return name
 
     def _qualify_value_name(self, name: str) -> str:
-        """Qualify a value name with the current scope using ``/`` separator.
+        """Qualify a value name with the current scope using ``.`` separator.
 
         The name is prefixed with ``v_`` to distinguish values from parameters.
         """
         parts = self.scope_names()
-        qualified = f"v_{name}"
         if parts:
-            return "/".join(parts) + "/" + qualified
-        return qualified
+            return "v_" + ".".join(parts) + "." + name
+        return f"v_{name}"
 
     def _qualify_node_name(self, name: str) -> str:
-        """Qualify a node name with the current scope using ``/`` separator."""
+        """Qualify a node name with the current scope using ``.`` separator."""
         parts = self.scope_names()
         if parts:
-            return "/".join(parts) + "/" + name
+            return ".".join(parts) + "." + name
         return name
 
     def _build_namespace(self, op_type: str, domain: str = "") -> str:
         """Build the namespace string for a node.
 
-        Format: ``scope1/scope2: domain.op_type`` or ``scope1/scope2: op_type``.
+        Format: ``scope1.scope2: domain.op_type`` or ``scope1.scope2: op_type``.
         """
-        scope = "/".join(self.scope_names())
+        scope = ".".join(self.scope_names())
         op_id = f"{domain}.{op_type}" if domain else op_type
         if scope:
             return f"{scope}: {op_id}"

onnxscript/_internal/builder_test.py

@@ -148,17 +148,17 @@ def test_value_naming_with_hierarchy(self):
         # Test custom names with hierarchical context
         op.builder.push_module("layer1")
         t2 = op.Mul(t1, y, _outputs=["my_mul"])
-        self.assertEqual(t2.name, "layer1/v_my_mul")
+        self.assertEqual(t2.name, "v_layer1.my_mul")
 
         # Test nested hierarchical context with custom names
         op.builder.push_module("attention")
         t3 = op.Add(t2, x, _outputs=["my_nested_add"])
-        self.assertEqual(t3.name, "layer1/attention/v_my_nested_add")
+        self.assertEqual(t3.name, "v_layer1.attention.my_nested_add")
 
         # Pop back and verify prefix is applied correctly
         op.builder.pop_module()
         t4 = op.Mul(t3, y, _outputs=["another_mul"])
-        self.assertEqual(t4.name, "layer1/v_another_mul")
+        self.assertEqual(t4.name, "v_layer1.another_mul")
 
         op.builder.pop_module()
         t5 = op.Add(t4, x, _outputs=["final_result"])
@@ -181,13 +181,13 @@ def test_value_naming_with_ir_value_objects(self):
         # Test with hierarchical context
         op.builder.push_module("layer1")
         t2 = op.Mul(t1, y, _outputs=[out2])
-        self.assertEqual(t2.name, "layer1/v_layer_output")
+        self.assertEqual(t2.name, "v_layer1.layer_output")
         self.assertIs(t2, out2)
 
         # Test nested hierarchical context
         op.builder.push_module("attention")
         t3 = op.Add(t2, x, _outputs=[out3])
-        self.assertEqual(t3.name, "layer1/attention/v_nested_output")
+        self.assertEqual(t3.name, "v_layer1.attention.nested_output")
         self.assertIs(t3, out3)
 
     def test_default_output_naming_strategy(self):
@@ -239,20 +239,20 @@ def test_hierarchical_naming(self):
         # Test node and value naming with hierarchical context prefix
         op.builder.push_module("layer1")
         t3 = op.Add(t2, x)
-        self.assertEqual(t3.name, "layer1/v_Add_2")
-        self.assertEqual(t3.producer().name, "layer1/Add_node_2")
+        self.assertEqual(t3.name, "v_layer1.Add_2")
+        self.assertEqual(t3.producer().name, "layer1.Add_node_2")
 
         # Test nested hierarchical context
         op.builder.push_module("attention")
         t4 = op.Mul(t3, y)
-        self.assertEqual(t4.name, "layer1/attention/v_Mul_3")
-        self.assertEqual(t4.producer().name, "layer1/attention/Mul_node_3")
+        self.assertEqual(t4.name, "v_layer1.attention.Mul_3")
+        self.assertEqual(t4.producer().name, "layer1.attention.Mul_node_3")
 
         # Pop back to layer1 and verify naming continues correctly
         op.builder.pop_module()
         t5 = op.Add(t4, x)
-        self.assertEqual(t5.name, "layer1/v_Add_4")
-        self.assertEqual(t5.producer().name, "layer1/Add_node_4")
+        self.assertEqual(t5.name, "v_layer1.Add_4")
+        self.assertEqual(t5.producer().name, "layer1.Add_node_4")
 
         # Pop back to root context
         op.builder.pop_module()
@@ -566,7 +566,7 @@ def test_node_metadata_props_namespace(self):
         op.builder.push_module("self_attn", "Attention")
         t3 = op.Add(t2, x)
         self.assertEqual(
-            t3.producer().metadata_props["namespace"], "layer1/self_attn: Add"
+            t3.producer().metadata_props["namespace"], "layer1.self_attn: Add"
         )
         op.builder.pop_module()
         op.builder.pop_module()