Use monic_bind and monic_bind_module instead of register and register_module

Author: jaepil

examples/http/main.py

@@ -13,7 +13,7 @@
     ExpressionsContext,
     ExpressionsParser,
     ExpressionsInterpreter,
-    register,
+    monic_bind,
 )
 
 
@@ -25,7 +25,7 @@ class ComputeInput(BaseModel):
     timeout: float = 10.0
 
 
-@register
+@monic_bind
 def say_hello(name: str) -> str:
     return f"Hello, {name}!"
 

monic/expressions/__init__.py

@@ -11,7 +11,12 @@
 )
 from monic.expressions.interpreter import ExpressionsInterpreter
 from monic.expressions.parser import ExpressionsParser
-from monic.expressions.registry import register, register_module
+from monic.expressions.registry import (
+    monic_bind,
+    monic_bind_module,
+    register,
+    register_module,
+)
 
 
 __all__ = [
@@ -23,6 +28,8 @@
     "SecurityError",
     "UnsupportedUnpackingError",
     # Registry
+    "monic_bind",
+    "monic_bind_module",
     "register",
     "register_module",
 ]

monic/expressions/registry.py

@@ -285,3 +285,9 @@ def get(self, name: str) -> t.Any:
 
 # Function for registering modules
 register_module = registry.register_module
+
+# Decorator for binding objects to the registry
+monic_bind = registry.register
+
+# Function for binding modules to the registry
+monic_bind_module = registry.register_module

tests/expressions/test_interpreter_coverage1.py

@@ -13,7 +13,7 @@
     ExpressionsInterpreter,
     UnsupportedUnpackingError,
     SecurityError,
-    register,
+    monic_bind,
 )
 from monic.expressions.registry import registry
 
@@ -38,7 +38,7 @@ def test_complex_method_handling():
     interpreter = ExpressionsInterpreter()
 
     # Test property descriptor
-    @register("test.TestClass")
+    @monic_bind("test.TestClass")
     class TestClass:
         def __init__(self):
             self._value = 0
@@ -339,22 +339,22 @@ def test_registry_error_paths():
         ValueError, match="is already registered as a non-namespace"
     ):
 
-        @register("test")
+        @monic_bind("test")
         def test_func():
             return 42  # pragma: no cover
 
-        @register("test.func")
+        @monic_bind("test.func")
         def test_func2():
             return 43  # pragma: no cover
 
     # Test duplicate registration
-    @register("math.add")
+    @monic_bind("math.add")
     def add1():
         return 42  # pragma: no cover
 
     with pytest.raises(ValueError, match="already registered"):
 
-        @register("math.add")
+        @monic_bind("math.add")
         def add2():
             return 43  # pragma: no cover
 

tests/expressions/test_interpreter_registry.py

@@ -11,8 +11,8 @@
 from monic.expressions import (
     ExpressionsParser,
     ExpressionsInterpreter,
-    register,
-    register_module,
+    monic_bind,
+    monic_bind_module,
 )
 from monic.expressions.registry import registry, NamespaceProxy
 
@@ -27,12 +27,12 @@ def reset_registry():
 def test_registered_function():
     """Test using registered functions."""
 
-    @register
+    @monic_bind
     def custom_add(x, y):  # pylint: disable=unused-variable
         """Custom addition function."""
         return x + y
 
-    @register("multiply")
+    @monic_bind("multiply")
     def custom_multiply(x, y):  # pylint: disable=unused-variable
         """Custom multiplication function."""
         return x * y
@@ -52,7 +52,7 @@ def custom_multiply(x, y):  # pylint: disable=unused-variable
 def test_registered_class():
     """Test using registered class."""
 
-    @register
+    @monic_bind
     class Point:  # pylint: disable=unused-variable
         """A simple 2D point class."""
 
@@ -77,7 +77,7 @@ def distance_from_origin(self):
 def test_register_without_name():
     """Test registering an object without explicit name."""
 
-    @register
+    @monic_bind
     def test_func():  # pylint: disable=unused-variable
         return 42
 
@@ -92,7 +92,7 @@ def test_func():  # pylint: disable=unused-variable
 def test_register_with_name():
     """Test registering an object with explicit name."""
 
-    @register("answer")
+    @monic_bind("answer")
     def get_answer():  # pylint: disable=unused-variable
         return 42
 
@@ -107,15 +107,15 @@ def get_answer():  # pylint: disable=unused-variable
 def test_register_with_nested_name():
     """Test registering objects with nested names."""
 
-    @register("math.functions.add")
+    @monic_bind("math.functions.add")
     def add(x, y):  # pylint: disable=unused-variable
         return x + y
 
-    @register("math.functions.multiply")
+    @monic_bind("math.functions.multiply")
     def multiply(x, y):  # pylint: disable=unused-variable
         return x * y
 
-    @register("math.constants")
+    @monic_bind("math.constants")
     class MathConstants:  # pylint: disable=unused-variable
         PI = 3.14159
         E = 2.71828
@@ -139,14 +139,14 @@ class MathConstants:  # pylint: disable=unused-variable
 def test_register_nested_name_conflict():
     """Test that registering conflicting nested names raises an error."""
 
-    @register("math.functions.add")
+    @monic_bind("math.functions.add")
     def add1(x, y):  # pylint: disable=unused-variable
         return x + y  # pragma: no cover
 
     # Try to register another function with the same nested name
     with pytest.raises(ValueError) as exc_info:
 
-        @register("math.functions.add")
+        @monic_bind("math.functions.add")
         def add2(x, y):  # pylint: disable=unused-variable
             return x + y  # pragma: no cover
 
@@ -156,14 +156,14 @@ def add2(x, y):  # pylint: disable=unused-variable
 def test_register_nested_name_non_namespace_conflict():
     """Test conflict between nested name and non-namespace object."""
 
-    @register("math")
+    @monic_bind("math")
     def math_func():  # pylint: disable=unused-variable
         return 42  # pragma: no cover
 
     # Try to register a function in math.functions namespace
     with pytest.raises(ValueError) as exc_info:
 
-        @register("math.functions.add")
+        @monic_bind("math.functions.add")
         def add(x, y):  # pylint: disable=unused-variable
             return x + y  # pragma: no cover
 
@@ -173,11 +173,11 @@ def add(x, y):  # pylint: disable=unused-variable
 def test_register_both_syntaxes():
     """Test both decorator syntaxes work correctly."""
 
-    @register
+    @monic_bind
     def func1():  # pylint: disable=unused-variable
         return 1
 
-    @register()
+    @monic_bind()
     def func2():  # pylint: disable=unused-variable
         return 2
 
@@ -196,11 +196,11 @@ def func2():  # pylint: disable=unused-variable
 def test_register_class_both_syntaxes():
     """Test both decorator syntaxes work correctly with classes."""
 
-    @register
+    @monic_bind
     class Class1:  # pylint: disable=unused-variable
         value = 1
 
-    @register()
+    @monic_bind()
     class Class2:  # pylint: disable=unused-variable
         value = 2
 
@@ -218,10 +218,10 @@ class Class2:  # pylint: disable=unused-variable
     assert interpreter.get_name_value("result2") == 2
 
 
-def test_register_module():
+def test_bind_module():
     """Test registering and using a module."""
-    # Register math module
-    register_module("math")
+    # Bind math module
+    monic_bind_module("math")
 
     code = """
     result1 = math.sqrt(16)
@@ -237,10 +237,10 @@ def test_register_module():
     )
 
 
-def test_register_module_with_alias():
+def test_bind_module_with_alias():
     """Test registering a module with an alias."""
-    # Register random module with alias
-    register_module("random", alias="rand")
+    # Bind random module with alias
+    monic_bind_module("random", alias="rand")
 
     code = """
     rand.seed(42)  # For reproducibility
@@ -255,10 +255,10 @@ def test_register_module_with_alias():
     assert 1 <= result <= 10
 
 
-def test_register_module_submodule():
+def test_bind_module_submodule():
     """Test registering a module with submodules."""
-    # Register collections.abc module
-    register_module("collections.abc", alias="collabc")
+    # Bind collections.abc module
+    monic_bind_module("collections.abc", alias="collabc")
 
     code = """
     is_sequence = collabc.Sequence
@@ -272,11 +272,11 @@ def test_register_module_submodule():
     assert result is True
 
 
-def test_register_module_with_nested_name():
+def test_bind_module_with_nested_name():
     """Test registering modules with nested names."""
-    # Register urllib and its parse submodule
-    register_module("urllib", alias="url")
-    register_module("urllib.parse", alias="url.parse")
+    # Bind urllib and its parse submodule
+    monic_bind_module("urllib", alias="url")
+    monic_bind_module("urllib.parse", alias="url.parse")
 
     code = """
     # Use urllib.parse module
@@ -336,34 +336,34 @@ def test_register_object_without_name():
     )
 
 
-def test_register_module_import_error():
+def test_bind_module_import_error():
     """Test that registering a non-existent module raises ImportError."""
     with pytest.raises(ImportError) as exc_info:
-        register_module("non_existent_module")
+        monic_bind_module("non_existent_module")
 
     assert "Failed to import module 'non_existent_module'" in str(
         exc_info.value
     )
 
 
-def test_register_module_duplicate():
+def test_bind_module_duplicate():
     """Test that registering the same module twice raises ValueError."""
-    register_module("math")
+    monic_bind_module("math")
 
     with pytest.raises(ValueError) as exc_info:
-        register_module("math")
+        monic_bind_module("math")
 
     assert "Module 'math' is already registered" in str(exc_info.value)
 
 
 def test_get_all_with_nested_namespaces():
     """Test that get_all properly handles nested namespaces."""
 
-    @register("math.functions.add")
+    @monic_bind("math.functions.add")
     def add(x, y):  # pylint: disable=unused-variable
         return x + y  # pragma: no cover
 
-    @register("math.constants")
+    @monic_bind("math.constants")
     class Constants:  # pylint: disable=unused-variable
         PI = 3.14159
 
@@ -411,8 +411,8 @@ def test_func():
 
 def test_get_all_with_modules():
     """Test that get_all properly includes registered modules."""
-    register_module("math", alias="math_alias")
-    register_module("random")
+    monic_bind_module("math", alias="math_alias")
+    monic_bind_module("random")
 
     all_objects = registry.get_all()
     assert "math_alias" in all_objects
@@ -475,16 +475,16 @@ def test_get_all_with_mixed_content():
     Test that get_all properly handles mixed content
     (modules, objects, namespaces).
     """
-    # Register a module
-    register_module("math")
+    # Bind a module
+    monic_bind_module("math")
 
-    # Register a function in a namespace
-    @register("utils.helper")
+    # Bind a function in a namespace
+    @monic_bind("utils.helper")
     def helper():  # pylint: disable=unused-variable
         pass  # pragma: no cover
 
-    # Register a direct object
-    @register
+    # Bind a direct object
+    @monic_bind
     def direct_func():  # pylint: disable=unused-variable
         pass  # pragma: no cover
 
@@ -498,7 +498,7 @@ def direct_func():  # pylint: disable=unused-variable
 def test_is_registered_with_string_name():
     """Test is_registered with a string name."""
 
-    @register("test.func")
+    @monic_bind("test.func")
     def test_func():  # pylint: disable=unused-variable
         pass  # pragma: no cover
 
@@ -509,15 +509,15 @@ def test_func():  # pylint: disable=unused-variable
 def test_get_all_with_non_dict_values():
     """Test that get_all properly handles non-dict values."""
 
-    @register("test.value")
+    @monic_bind("test.value")
     def test_func():  # pylint: disable=unused-variable
         pass  # pragma: no cover
 
-    @register("direct_value")
+    @monic_bind("direct_value")
     def direct_func():  # pylint: disable=unused-variable
         pass  # pragma: no cover
 
-    register_module("math")
+    monic_bind_module("math")
 
     all_objects = registry.get_all()
     assert callable(all_objects["test"].value)  # Nested function