Test fixes

Author: tanner-andrulis

tests/vibe_see_readme_in_this_dir/test_parsed_values.py

@@ -433,12 +433,6 @@ def test_I_input_name(self):
         i_einsum = self.wl.einsums["I"]
         self.assertEqual(i_einsum.input_tensor_names, {"I_in"})
 
-    def test_I_inline_renames(self):
-        """I einsum string: I(output)[b,m,d] = I_in(input)[b,m,d]"""
-        i_einsum = self.wl.einsums["I"]
-        renames_by_name = {r.name: r.source for r in i_einsum.renames}
-        self.assertEqual(renames_by_name["output"], "I")
-        self.assertEqual(renames_by_name["input"], "I_in")
 
     def test_I_projection_parsed_as_dict(self):
         """Concise einsum string projections are parsed by _parse_projection, which
@@ -463,31 +457,24 @@ def test_V_output(self):
         self.assertEqual(v.output_tensor_names, {"V"})
 
     def test_QK_uses_dict_projection(self):
-        """QK: K(weight)[b, M=p, h, e] uses a dict projection for K."""
+        """QK: K[b, M:p, h, e] uses a dict projection for K."""
         qk = self.wl.einsums["QK"]
         k_ta = qk.tensor_accesses["K"]
-        # M=p is explicit, so it's not an ImpliedProjection
+        # M:p is explicit, so it's not an ImpliedProjection
         self.assertNotIsInstance(k_ta.projection, ImpliedProjection)
         self.assertEqual(k_ta.projection["M"], "p")
 
     def test_QK_Q_projection_is_dict(self):
-        """Q(input)[b, m, h, e] -- from a concise string, parsed as a plain dict."""
+        """Q[b, m, h, e] -- from a concise string, parsed as a plain dict."""
         qk = self.wl.einsums["QK"]
         q_ta = qk.tensor_accesses["Q"]
         self.assertNotIsInstance(q_ta.projection, ImpliedProjection)
         self.assertEqual(
             dict(q_ta.projection), {"B": "b", "M": "m", "H": "h", "E": "e"}
         )
 
-    def test_QK_inline_renames(self):
-        """QK: Q(input), K(weight) -> renames: {input: Q, weight: K}"""
-        qk = self.wl.einsums["QK"]
-        renames_by_name = {r.name: r.source for r in qk.renames}
-        self.assertEqual(renames_by_name["input"], "Q")
-        self.assertEqual(renames_by_name["weight"], "K")
-
     def test_AV_dict_projection_V(self):
-        """AV: V(weight)[b, M=p, H=h, E=f]"""
+        """AV: V[b, M:p, H:h, E:f]"""
         av = self.wl.einsums["AV"]
         v_ta = av.tensor_accesses["V"]
         self.assertNotIsInstance(v_ta.projection, ImpliedProjection)

tests/vibe_see_readme_in_this_dir/test_workload_parser.py

@@ -42,7 +42,7 @@ def test_simple_einsum_list_projection(self):
         self.assertTrue(output["output"])
 
     def test_einsum_with_dict_projection(self):
-        einsum_str = "QK[b, m, p, h] = Q[b, m, h, e] * K[B=b, M=p, H=h, E=e]"
+        einsum_str = "QK[b, m, p, h] = Q[b, m, h, e] * K[B:b, M:p, H:h, E:e]"
         result = _parse_einsum_string(einsum_str)
 
         self.assertEqual(result["name"], "QK")
@@ -56,7 +56,7 @@ def test_einsum_with_dict_projection(self):
 
     def test_einsum_with_mixed_projection(self):
         """Test parsing einsum with mixed-style projection using equals."""
-        einsum_str = "QK[b, m, p, h] = Q[b, m, h, e] * K[b, M=p, h, e]"
+        einsum_str = "QK[b, m, p, h] = Q[b, m, h, e] * K[b, M:p, h, e]"
         result = _parse_einsum_string(einsum_str)
 
         # Check the K tensor with mixed projection
@@ -86,13 +86,13 @@ def test_einsum_malformed_no_equals(self):
         """Test that parsing fails when there's no equals sign."""
         with self.assertRaises(ValueError) as ctx:
             _parse_einsum_string("V[b, m, h, e]")
-        self.assertIn("Invalid einsum format:", str(ctx.exception))
+        self.assertIn("Invalid einsum format", str(ctx.exception))
 
     def test_einsum_malformed_no_brackets(self):
         """Test that parsing fails when brackets are missing."""
         with self.assertRaises(ValueError) as ctx:
             _parse_einsum_string("V = I * WV")
-        self.assertIn("Invalid einsum format:", str(ctx.exception))
+        self.assertIn("Invalid einsum format", str(ctx.exception))
 
     def test_einsum_malformed_empty_projection(self):
         """Test that parsing fails with empty projection."""
@@ -138,7 +138,7 @@ def test_einsum_empty_tensor_name(self):
         """Test that empty tensor names raise an error."""
         with self.assertRaises(ValueError) as ctx:
             _parse_einsum_string("[b, m] = I[b] * W[m]")
-        self.assertIn("Invalid einsum format:", str(ctx.exception))
+        self.assertIn("Invalid einsum format", str(ctx.exception))
 
     def test_projection_invalid_identifier(self):
         with self.assertRaises(ValueError):
@@ -313,7 +313,7 @@ def test_very_long_tensor_name(self):
 
     def test_projection_equals_without_space(self):
         """Test mixed projection with no spaces around equals."""
-        result = _parse_einsum_string("V[b] = I[B=b]")
+        result = _parse_einsum_string("V[b] = I[B:b]")
         self.assertEqual(result["tensor_accesses"][0]["projection"], {"B": "b"})
 
     def test_multiple_asterisks(self):
@@ -341,13 +341,11 @@ def test_parse_string_entry(self):
 
     def test_parse_dict_entry_with_einsum_key(self):
         entry = {
-            "einsum": "QK[b, m, p, h] = Q[b, m, h, e] * K[b, M=p, h, e]",
-            "renames": {"weight": "K", "input": "Q"},
+            "einsum": "QK[b, m, p, h] = Q[b, m, h, e] * K[b, M:p, h, e]",
         }
         result = _parse_einsum_entry(entry)
 
         self.assertEqual(result["name"], "QK")
-        self.assertEqual(result["renames"], {"weight": "K", "input": "Q"})
 
     def test_parse_dict_entry_full_format(self):
         entry = {

tests/vibe_see_readme_in_this_dir/test_workload_parsing.py

@@ -33,19 +33,19 @@ def test_simple_identifiers_become_dict(self):
         self.assertEqual(result, {"A": "a", "B": "b", "C": "c"})
 
     def test_explicit_equals_projection(self):
-        result = _parse_projection("B=b, M=p, H=h, E=e")
+        result = _parse_projection("B:b, M:p, H:h, E:e")
         self.assertEqual(result, {"B": "b", "M": "p", "H": "h", "E": "e"})
 
     def test_mixed_implicit_and_explicit(self):
-        result = _parse_projection("b, M=p, h, e")
+        result = _parse_projection("b, M:p, h, e")
         self.assertEqual(result, {"B": "b", "M": "p", "H": "h", "E": "e"})
 
     def test_single_element(self):
         result = _parse_projection("x")
         self.assertEqual(result, {"X": "x"})
 
     def test_single_explicit(self):
-        result = _parse_projection("X=y")
+        result = _parse_projection("X:y")
         self.assertEqual(result, {"X": "y"})
 
     def test_empty_raises_value_error(self):
@@ -193,7 +193,7 @@ def test_single_input_tensor(self):
 
     def test_dict_projection(self):
         result = _parse_einsum_string(
-            "QK[b, m, p, h] = Q[b, m, h, e] * K[B=b, M=p, H=h, E=e]"
+            "QK[b, m, p, h] = Q[b, m, h, e] * K[B:b, M:p, H:h, E:e]"
         )
         k_tensor = result["tensor_accesses"][1]
         self.assertEqual(k_tensor["name"], "K")
@@ -203,20 +203,12 @@ def test_dict_projection(self):
 
     def test_mixed_projection(self):
         result = _parse_einsum_string(
-            "QK[b, m, p, h] = Q[b, m, h, e] * K[b, M=p, h, e]"
+            "QK[b, m, p, h] = Q[b, m, h, e] * K[b, M:p, h, e]"
         )
         k_tensor = result["tensor_accesses"][1]
         expected = {"B": "b", "M": "p", "H": "h", "E": "e"}
         self.assertEqual(k_tensor["projection"], expected)
 
-    def test_with_renames_alias(self):
-        result = _parse_einsum_string(
-            "QK(output)[b, m, p, h] = Q(input)[b, m, h, e] * K(weight)[b, M=p, h, e]"
-        )
-        self.assertEqual(result["name"], "QK")
-        self.assertEqual(
-            result["renames"], {"output": "QK", "input": "Q", "weight": "K"}
-        )
 
     def test_copy_operation(self):
         result = _parse_einsum_string("I[b, m, d] = I_in[b, m, d]")
@@ -300,7 +292,7 @@ def test_entry_with_einsum_key(self):
 
     def test_entry_with_einsum_and_renames(self):
         entry = {
-            "einsum": "QK[b, m, p, h] = Q[b, m, h, e] * K[b, M=p, h, e]",
+            "einsum": "QK[b, m, p, h] = Q[b, m, h, e] * K[b, M:p, h, e]",
             "renames": {"weight": "K", "input": "Q"},
         }
         result = _parse_einsum_entry(entry)
@@ -375,16 +367,6 @@ def test_invalid_tensor_accesses_type_raises(self):
         with self.assertRaises(ValueError):
             _parse_einsum_entry(entry)
 
-    def test_rename_already_in_einsum_string_raises(self):
-        """If the einsum string defines a rename alias and we try to add the same."""
-        entry = {
-            "einsum": "QK(output)[b] = Q(input)[b]",
-            "renames": {"output": "QK"},  # output is already set by alias
-        }
-        with self.assertRaises(ValueError) as ctx:
-            _parse_einsum_entry(entry)
-        self.assertIn("already exists", str(ctx.exception))
-
 
 if __name__ == "__main__":
     unittest.main()

tests/vibe_see_readme_in_this_dir/test_yaml_and_expressions.py

@@ -490,14 +490,6 @@ def test_einsum_keyword_preserves_tensor_accesses(self):
         names = {ta["name"] for ta in parsed["tensor_accesses"]}
         self.assertEqual(names, {"A", "B", "C"})
 
-    def test_einsum_keyword_with_extra_renames(self):
-        entry = {
-            "einsum": "C[m, n] = A[m, k] * B[k, n]",
-            "renames": {"weight": "B"},
-        }
-        parsed = _parse_einsum_entry(entry)
-        self.assertEqual(parsed["renames"]["weight"], "B")
-
     def test_conflicting_tensor_access_attr_raises(self):
         """Setting projection in both einsum string and tensor_accesses is an error."""
         entry = {
@@ -515,15 +507,6 @@ def test_nonexistent_tensor_in_extras_raises(self):
         with self.assertRaises(ValueError):
             _parse_einsum_entry(entry)
 
-    def test_duplicate_rename_raises(self):
-        """If the einsum string already defines a rename, adding the same raises."""
-        entry = {
-            "einsum": "C(output)[m, n] = A[m, k] * B[k, n]",
-            "renames": {"output": "C"},
-        }
-        with self.assertRaises(ValueError):
-            _parse_einsum_entry(entry)
-
     def test_is_copy_operation_not_forwarded(self):
         """Extra keys like is_copy_operation are NOT forwarded by _parse_einsum_entry."""
         entry = {
@@ -929,8 +912,8 @@ class TestParseProjectionDocExamples(unittest.TestCase):
     """Test _parse_projection for cases shown in the docs."""
 
     def test_mixed_implicit_and_explicit(self):
-        """Parsing 'b, M=p, h, e' yields a dict with mixed implicit/explicit."""
-        result = _parse_projection("b, M=p, h, e")
+        """Parsing 'b, M:p, h, e' yields a dict with mixed implicit/explicit."""
+        result = _parse_projection("b, M:p, h, e")
         self.assertEqual(result["B"], "b")
         self.assertEqual(result["M"], "p")
         self.assertEqual(result["H"], "h")
@@ -941,7 +924,7 @@ def test_all_implicit(self):
         self.assertEqual(result, {"M": "m", "K": "k", "N": "n"})
 
     def test_all_explicit(self):
-        result = _parse_projection("Row=m, Col=n")
+        result = _parse_projection("Row:m, Col:n")
         self.assertEqual(result, {"Row": "m", "Col": "n"})