Improve CPython compatibility for value unpacking

Author: jaepil

monic/expressions/__init__.py

@@ -5,10 +5,7 @@
 #
 
 from monic.expressions.context import ExpressionsContext
-from monic.expressions.exceptions import (
-    SecurityError,
-    UnsupportedUnpackingError,
-)
+from monic.expressions.exceptions import SecurityError
 from monic.expressions.interpreter import ExpressionsInterpreter
 from monic.expressions.parser import ExpressionsParser
 from monic.expressions.registry import (
@@ -26,7 +23,6 @@
     "ExpressionsParser",
     # Exceptions
     "SecurityError",
-    "UnsupportedUnpackingError",
     # Registry
     "monic_bind",
     "monic_bind_module",

monic/expressions/exceptions.py

@@ -7,7 +7,3 @@
 
 class SecurityError(Exception):
     """Raised when dangerous operations are detected."""
-
-
-class UnsupportedUnpackingError(Exception):
-    """Raised when an unsupported unpacking pattern is encountered."""

monic/expressions/interpreter.py

@@ -20,10 +20,7 @@
 from dataclasses import dataclass, field
 
 from monic.expressions.context import ExpressionsContext
-from monic.expressions.exceptions import (
-    SecurityError,
-    UnsupportedUnpackingError,
-)
+from monic.expressions.exceptions import SecurityError
 from monic.expressions.registry import registry
 
 
@@ -178,7 +175,6 @@ def __init__(self, context: ExpressionsContext | None = None) -> None:
             "TimeoutError": TimeoutError,
             "RuntimeError": RuntimeError,
             "SecurityError": SecurityError,
-            "UnsupportedUnpackingError": UnsupportedUnpackingError,
         }
 
         # Add registered objects to global environment
@@ -622,8 +618,7 @@ def _handle_unpacking_target(self, target: ast.AST, value: t.Any) -> None:
             value: The value being assigned
 
         Raises:
-            UnsupportedUnpackingError: If an unsupported unpacking pattern is
-            encountered
+            TypeError: If an unsupported unpacking pattern is encountered
         """
         if isinstance(target, ast.Name):
             self._handle_name_target(target, value)
@@ -634,9 +629,7 @@ def _handle_unpacking_target(self, target: ast.AST, value: t.Any) -> None:
         elif isinstance(target, (ast.Tuple, ast.List)):
             self._handle_sequence_unpacking(target, value)
         else:
-            raise UnsupportedUnpackingError(
-                f"Unsupported unpacking target type: {type(target).__name__}"
-            )
+            raise TypeError(f"cannot unpack {type(target).__name__}")
 
     def _handle_sequence_unpacking(
         self,
@@ -650,13 +643,17 @@ def _handle_sequence_unpacking(
             value: Value to unpack
 
         Raises:
-            ValueError: If value cannot be unpacked
-            UnsupportedUnpackingError: If unpacking pattern is not supported
+            TypeError: If value cannot be unpacked
+            ValueError: If there are too many or too few values to unpack
+            SyntaxError: If multiple starred expressions are used
         """
         with ScopeContext(self):
             try:
                 if not hasattr(value, "__iter__"):
-                    raise ValueError("Cannot unpack non-iterable value")
+                    raise TypeError(
+                        f"cannot unpack non-iterable {type(value).__name__} "
+                        "object"
+                    )
 
                 # Check for starred expressions (extended unpacking)
                 starred_indices = [
@@ -666,8 +663,8 @@ def _handle_sequence_unpacking(
                 ]
 
                 if len(starred_indices) > 1:
-                    raise UnsupportedUnpackingError(
-                        "Cannot use multiple starred expressions in assignment"
+                    raise SyntaxError(
+                        "multiple starred expressions in assignment"
                     )
 
                 if starred_indices:
@@ -683,15 +680,21 @@ def _handle_sequence_unpacking(
                     # Standard unpacking without starred expression
                     value_list = list(value)
                     if len(value_list) < len(target.elts):
-                        raise ValueError("Not enough values to unpack")
+                        raise ValueError(
+                            "not enough values to unpack (expected "
+                            f"{len(target.elts)}, got {len(value_list)})"
+                        )
                     elif len(value_list) > len(target.elts):
-                        raise ValueError("Too many values to unpack")
+                        raise ValueError(
+                            "too many values to unpack (expected "
+                            f"{len(target.elts)})"
+                        )
 
                     # Unpack each element
                     for tgt, val in zip(target.elts, value):
                         self._handle_unpacking_target(tgt, val)
-            except (TypeError, ValueError) as e:
-                raise UnsupportedUnpackingError(str(e)) from e
+            except (TypeError, ValueError, SyntaxError) as e:
+                raise type(e)(str(e)) from e
 
     def _handle_starred_unpacking(
         self,
@@ -710,7 +713,7 @@ def _handle_starred_unpacking(
 
         Raises:
             ValueError: If there are not enough values to unpack
-            UnsupportedUnpackingError: If unpacking pattern is not supported
+            TypeError: If target is not a valid unpacking target
         """
         with ScopeContext(self):
             iter_value = iter(value)
@@ -721,7 +724,7 @@ def _handle_starred_unpacking(
                 try:
                     self._handle_unpacking_target(tgt, next(iter_value))
                 except StopIteration as e:
-                    raise ValueError("Not enough values to unpack") from e
+                    raise ValueError("not enough values to unpack") from e
 
             # Collect remaining elements for the starred target
             starred_values = list(iter_value)
@@ -733,7 +736,7 @@ def _handle_starred_unpacking(
             if after_star_count > 0:
                 # Make sure there are enough elements
                 if len(starred_values) < after_star_count:
-                    raise ValueError("Not enough values to unpack")
+                    raise ValueError("not enough values to unpack")
 
                 # Separate starred values
                 starred_list = starred_values[:-after_star_count]
@@ -742,6 +745,8 @@ def _handle_starred_unpacking(
                 # Assign starred target
                 if isinstance(starred_target.value, ast.Name):
                     self._set_name_value(starred_target.value.id, starred_list)
+                else:
+                    raise TypeError("starred assignment target must be a name")
 
                 # Assign elements after starred
                 after_elements = target_elts[star_index + 1 :]
@@ -754,6 +759,8 @@ def _handle_starred_unpacking(
                     self._set_name_value(
                         starred_target.value.id, starred_values
                     )
+                else:
+                    raise TypeError("starred assignment target must be a name")
 
     def visit_NamedExpr(self, node: ast.NamedExpr) -> t.Any:
         """Handle named expressions (walrus operator).
@@ -1725,7 +1732,7 @@ def process_generator(
                             self._handle_unpacking_target(
                                 generator.target, item
                             )
-                        except UnsupportedUnpackingError:
+                        except (TypeError, ValueError, SyntaxError):
                             if isinstance(generator.target, ast.Name):
                                 self._set_name_value(generator.target.id, item)
                             else:
@@ -1803,14 +1810,16 @@ def _process_generator_item(
             bool: Whether all conditions are met
 
         Raises:
-            UnsupportedUnpackingError: If target unpacking fails
+            TypeError: If value is not iterable
+            ValueError: If target unpacking fails
+            SyntaxError: If multiple starred expressions are used
         """
         # Restore environment from before this generator's loop
         self.local_env = current_env.copy()
 
         try:
             self._handle_unpacking_target(generator.target, item)
-        except UnsupportedUnpackingError:
+        except (TypeError, ValueError, SyntaxError):
             if isinstance(generator.target, ast.Name):
                 self._set_name_value(generator.target.id, item)
             else:

tests/expressions/test_interpreter_coverage1.py

@@ -11,7 +11,6 @@
 from monic.expressions import (
     ExpressionsParser,
     ExpressionsInterpreter,
-    UnsupportedUnpackingError,
     SecurityError,
     monic_bind,
 )
@@ -386,7 +385,7 @@ def test_error_handling_edge_cases():
 """
     tree = parser.parse(code)
     with pytest.raises(
-        UnsupportedUnpackingError, match="Cannot unpack non-iterable"
+        TypeError, match="cannot unpack non-iterable int object"
     ):
         interpreter.execute(tree)
 
@@ -395,19 +394,15 @@ def test_error_handling_edge_cases():
 a, b = [1, 2, 3]  # Too many values
 """
     tree = parser.parse(code)
-    with pytest.raises(
-        UnsupportedUnpackingError, match="Too many values to unpack"
-    ):
+    with pytest.raises(ValueError, match="too many values to unpack"):
         interpreter.execute(tree)
 
     # Test not enough values to unpack
     code = """
 a, b, c = [1, 2]  # Not enough values
 """
     tree = parser.parse(code)
-    with pytest.raises(
-        UnsupportedUnpackingError, match="Not enough values to unpack"
-    ):
+    with pytest.raises(ValueError, match="not enough values to unpack"):
         interpreter.execute(tree)
 
     # Test invalid starred unpacking
@@ -416,8 +411,8 @@ def test_error_handling_edge_cases():
 """
     tree = parser.parse(code)
     with pytest.raises(
-        UnsupportedUnpackingError,
-        match="Cannot use multiple starred expressions",
+        SyntaxError,
+        match="multiple starred expressions in assignment",
     ):
         interpreter.execute(tree)
 

tests/expressions/test_interpreter_coverage4.py

@@ -11,7 +11,6 @@
 from monic.expressions import (
     ExpressionsParser,
     ExpressionsInterpreter,
-    UnsupportedUnpackingError,
 )
 from monic.expressions.registry import registry, NamespaceProxy, Registry
 
@@ -293,33 +292,31 @@ def test_unpacking_errors():
     a, b = [1, 2, 3]
     result = "should not reach here"
 except ValueError as e:
-    if str(e) == "Too many values to unpack":
+    if str(e) == "too many values to unpack (expected 2)":
         result = "too many values"
     else:
         result = str(e)
 result
 """
     tree = parser.parse(code)
-    with pytest.raises(UnsupportedUnpackingError) as exc_info:
-        interpreter.execute(tree)
-    assert str(exc_info.value) == "Too many values to unpack"
+    result = interpreter.execute(tree)
+    assert result == "too many values"
 
     # Test not enough values
     code = """
 try:
     a, b, c = [1, 2]
     result = "should not reach here"
 except ValueError as e:
-    if str(e) == "Not enough values to unpack":
+    if str(e) == "not enough values to unpack (expected 3, got 2)":
         result = "not enough values"
     else:
         result = str(e)
 result
 """
     tree = parser.parse(code)
-    with pytest.raises(UnsupportedUnpackingError) as exc_info:
-        interpreter.execute(tree)
-    assert str(exc_info.value) == "Not enough values to unpack"
+    result = interpreter.execute(tree)
+    assert result == "not enough values"
 
 
 def test_match_basic_sequence():
@@ -432,12 +429,10 @@ def test_unpacking_with_multiple_starred_expressions():
     parser = ExpressionsParser()
     interpreter = ExpressionsInterpreter()
 
-    with pytest.raises(UnsupportedUnpackingError) as exc_info:
+    with pytest.raises(SyntaxError) as exc_info:
         interpreter.execute(parser.parse(code))
 
-    assert "Cannot use multiple starred expressions in assignment" in str(
-        exc_info.value
-    )
+    assert "multiple starred expressions in assignment" in str(exc_info.value)
 
 
 def test_unpacking_with_insufficient_values():
@@ -449,10 +444,10 @@ def test_unpacking_with_insufficient_values():
     parser = ExpressionsParser()
     interpreter = ExpressionsInterpreter()
 
-    with pytest.raises(UnsupportedUnpackingError) as exc_info:
+    with pytest.raises(ValueError) as exc_info:
         interpreter.execute(parser.parse(code))
 
-    assert "Not enough values to unpack" in str(exc_info.value)
+    assert "not enough values to unpack" in str(exc_info.value)
 
 
 def test_unpacking_with_too_many_values():
@@ -464,10 +459,10 @@ def test_unpacking_with_too_many_values():
     parser = ExpressionsParser()
     interpreter = ExpressionsInterpreter()
 
-    with pytest.raises(UnsupportedUnpackingError) as exc_info:
+    with pytest.raises(ValueError) as exc_info:
         interpreter.execute(parser.parse(code))
 
-    assert "Too many values to unpack" in str(exc_info.value)
+    assert "too many values to unpack" in str(exc_info.value)
 
 
 def test_unpacking_non_iterable():
@@ -479,10 +474,10 @@ def test_unpacking_non_iterable():
     parser = ExpressionsParser()
     interpreter = ExpressionsInterpreter()
 
-    with pytest.raises(UnsupportedUnpackingError) as exc_info:
+    with pytest.raises(TypeError) as exc_info:
         interpreter.execute(parser.parse(code))
 
-    assert "Cannot unpack non-iterable value" in str(exc_info.value)
+    assert "cannot unpack non-iterable int object" in str(exc_info.value)
 
 
 def test_unpacking_with_attribute_target():

tests/expressions/test_interpreter_error_handling.py

@@ -10,7 +10,6 @@
     ExpressionsParser,
     ExpressionsInterpreter,
     SecurityError,
-    UnsupportedUnpackingError,
 )
 
 
@@ -45,28 +44,28 @@ def test_unpacking_errors():
 
     # Test unpacking non-iterable
     with pytest.raises(
-        UnsupportedUnpackingError, match="Cannot unpack non-iterable value"
+        TypeError, match="cannot unpack non-iterable int object"
     ):
         interpreter.execute(parser.parse("a, b = 42"))
 
     # Test too many values to unpack
     with pytest.raises(
-        UnsupportedUnpackingError,
-        match="Not enough values to unpack",
+        ValueError,
+        match="not enough values to unpack",
     ):
         interpreter.execute(parser.parse("a, b, c = [1, 2]"))
 
     # Test too few values to unpack
     with pytest.raises(
-        UnsupportedUnpackingError,
-        match="Too many values to unpack",
+        ValueError,
+        match="too many values to unpack",
     ):
         interpreter.execute(parser.parse("a, b = [1, 2, 3]"))
 
     # Test multiple starred expressions
     with pytest.raises(
-        UnsupportedUnpackingError,
-        match="Cannot use multiple starred expressions in assignment",
+        SyntaxError,
+        match="multiple starred expressions in assignment",
     ):
         interpreter.execute(parser.parse("*a, *b = [1, 2, 3]"))