mixinv2-library 0.4.0.post22.dev0__tar.gz → 0.4.0.post31.dev0__tar.gz

{mixinv2_library-0.4.0.post22.dev0 → mixinv2_library-0.4.0.post31.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mixinv2-library
-Version: 0.4.0.post22.dev0
+Version: 0.4.0.post31.dev0
 Summary: The MIXINv2 standard library — built-in definitions for MIXINv2
 Project-URL: Repository, https://github.com/Atry/MIXINv2
 Author-email: "Yang, Bo" <yang-bo@yang-bo.com>
@@ -10,4 +10,4 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.13
-Requires-Dist: mixinv2==0.4.0.post22.dev0
+Requires-Dist: mixinv2==0.4.0.post31.dev0

mixinv2_library-0.4.0.post31.dev0/src/mixinv2_library/Builtin/PythonOperator/__init__.py

@@ -0,0 +1,307 @@
+"""All Python operator module FFI wrappers, generated programmatically.
+
+Covers every public function in Python's operator module:
+- Binary (operand0, operand1 -> result): arithmetic, comparison, bitwise, sequence
+- Unary (operand -> result): neg, pos, abs, invert, not_, truth, index
+- In-place (operand0, operand1 -> result): iadd, isub, etc. (mutate + return)
+- Ternary (target, key, value -> result): setitem
+- Higher-order (target + params -> result): attrgetter, itemgetter, methodcaller, call
+- Special: length_hint, delitem
+"""
+
+import operator
+
+from mixinv2 import extern, public, resource
+from mixinv2._core import MappingScopeDefinition
+
+
+def _make_binary_operator(operation):
+    @extern
+    def operand0() -> object: ...
+
+    @extern
+    def operand1() -> object: ...
+
+    @public
+    @resource
+    def result(operand0: object, operand1: object) -> object:
+        return operation(operand0, operand1)
+
+    return MappingScopeDefinition(
+        inherits=(),
+        is_public=True,
+        underlying={"operand0": operand0, "operand1": operand1, "result": result},
+    )
+
+
+def _make_unary_operator(operation):
+    @extern
+    def operand() -> object: ...
+
+    @public
+    @resource
+    def result(operand: object) -> object:
+        return operation(operand)
+
+    return MappingScopeDefinition(
+        inherits=(),
+        is_public=True,
+        underlying={"operand": operand, "result": result},
+    )
+
+
+# --- Binary operators (operand0, operand1 -> result) ---
+_BINARY_OPERATORS = {
+    # Arithmetic
+    "Add": operator.add,
+    "Subtract": operator.sub,
+    "Multiply": operator.mul,
+    "TrueDivide": operator.truediv,
+    "FloorDivide": operator.floordiv,
+    "Modulo": operator.mod,
+    "Power": operator.pow,
+    "MatrixMultiply": operator.matmul,
+    # Comparison
+    "Equal": operator.eq,
+    "NotEqual": operator.ne,
+    "LessThan": operator.lt,
+    "LessThanOrEqual": operator.le,
+    "GreaterThan": operator.gt,
+    "GreaterThanOrEqual": operator.ge,
+    "Is": operator.is_,
+    "IsNot": operator.is_not,
+    # Bitwise
+    "BitwiseAnd": operator.and_,
+    "BitwiseOr": operator.or_,
+    "BitwiseXor": operator.xor,
+    "LeftShift": operator.lshift,
+    "RightShift": operator.rshift,
+    # Sequence
+    "Concatenate": operator.concat,
+    "Contains": operator.contains,
+    "GetItem": operator.getitem,
+    "CountOf": operator.countOf,
+    "IndexOf": operator.indexOf,
+}
+
+# --- Unary operators (operand -> result) ---
+_UNARY_OPERATORS = {
+    "Negate": operator.neg,
+    "Positive": operator.pos,
+    "Absolute": operator.abs,
+    "BitwiseInvert": operator.invert,
+    "Invert": operator.inv,
+    "LogicalNot": operator.not_,
+    "Truth": operator.truth,
+    "Index": operator.index,
+}
+
+# --- In-place operators (operand0, operand1 -> result) ---
+_INPLACE_OPERATORS = {
+    "InplaceAdd": operator.iadd,
+    "InplaceSubtract": operator.isub,
+    "InplaceMultiply": operator.imul,
+    "InplaceTrueDivide": operator.itruediv,
+    "InplaceFloorDivide": operator.ifloordiv,
+    "InplaceModulo": operator.imod,
+    "InplacePower": operator.ipow,
+    "InplaceMatrixMultiply": operator.imatmul,
+    "InplaceBitwiseAnd": operator.iand,
+    "InplaceBitwiseOr": operator.ior,
+    "InplaceBitwiseXor": operator.ixor,
+    "InplaceLeftShift": operator.ilshift,
+    "InplaceRightShift": operator.irshift,
+    "InplaceConcatenate": operator.iconcat,
+}
+
+for _name, _operation in _BINARY_OPERATORS.items():
+    globals()[_name] = _make_binary_operator(_operation)
+
+for _name, _operation in _UNARY_OPERATORS.items():
+    globals()[_name] = _make_unary_operator(_operation)
+
+for _name, _operation in _INPLACE_OPERATORS.items():
+    globals()[_name] = _make_binary_operator(_operation)
+
+
+# --- Special operators (hand-written, unique signatures) ---
+
+
+def _make_set_item():
+    """operator.setitem(target, key, value) -> None"""
+
+    @extern
+    def target() -> object: ...
+
+    @extern
+    def key() -> object: ...
+
+    @extern
+    def value() -> object: ...
+
+    @public
+    @resource
+    def result(target: object, key: object, value: object) -> None:
+        operator.setitem(target, key, value)
+
+    return MappingScopeDefinition(
+        inherits=(),
+        is_public=True,
+        underlying={"target": target, "key": key, "value": value, "result": result},
+    )
+
+
+SetItem = _make_set_item()
+
+
+def _make_delete_item():
+    """operator.delitem(target, key) -> None"""
+
+    @extern
+    def target() -> object: ...
+
+    @extern
+    def key() -> object: ...
+
+    @public
+    @resource
+    def result(target: object, key: object) -> None:
+        operator.delitem(target, key)
+
+    return MappingScopeDefinition(
+        inherits=(),
+        is_public=True,
+        underlying={"target": target, "key": key, "result": result},
+    )
+
+
+DeleteItem = _make_delete_item()
+
+
+def _make_length_hint():
+    """operator.length_hint(target) -> result"""
+
+    @extern
+    def target() -> object: ...
+
+    @public
+    @resource
+    def result(target: object) -> int:
+        return operator.length_hint(target)
+
+    return MappingScopeDefinition(
+        inherits=(),
+        is_public=True,
+        underlying={"target": target, "result": result},
+    )
+
+
+LengthHint = _make_length_hint()
+
+
+def _make_call():
+    """operator.call(target, *arguments) -> result"""
+
+    @extern
+    def target() -> object: ...
+
+    @extern
+    def arguments() -> tuple: ...
+
+    @public
+    @resource
+    def result(target: object, arguments: tuple) -> object:
+        return operator.call(target, *arguments)
+
+    return MappingScopeDefinition(
+        inherits=(),
+        is_public=True,
+        underlying={"target": target, "arguments": arguments, "result": result},
+    )
+
+
+Call = _make_call()
+
+
+def _make_method_call():
+    """operator.methodcaller(methodName, *arguments)(target) -> result"""
+
+    @extern
+    def target() -> object: ...
+
+    @extern
+    def methodName() -> str: ...
+
+    @extern
+    def arguments() -> tuple: ...
+
+    @public
+    @resource
+    def result(target: object, methodName: str, arguments: tuple) -> object:
+        return operator.methodcaller(methodName, *arguments)(target)
+
+    return MappingScopeDefinition(
+        inherits=(),
+        is_public=True,
+        underlying={
+            "target": target,
+            "methodName": methodName,
+            "arguments": arguments,
+            "result": result,
+        },
+    )
+
+
+MethodCall = _make_method_call()
+
+
+def _make_attribute_get():
+    """operator.attrgetter(attributeName)(target) -> result"""
+
+    @extern
+    def target() -> object: ...
+
+    @extern
+    def attributeName() -> str: ...
+
+    @public
+    @resource
+    def result(target: object, attributeName: str) -> object:
+        return operator.attrgetter(attributeName)(target)
+
+    return MappingScopeDefinition(
+        inherits=(),
+        is_public=True,
+        underlying={
+            "target": target,
+            "attributeName": attributeName,
+            "result": result,
+        },
+    )
+
+
+AttributeGet = _make_attribute_get()
+
+
+def _make_item_get():
+    """operator.itemgetter(key)(target) -> result"""
+
+    @extern
+    def target() -> object: ...
+
+    @extern
+    def key() -> object: ...
+
+    @public
+    @resource
+    def result(target: object, key: object) -> object:
+        return operator.itemgetter(key)(target)
+
+    return MappingScopeDefinition(
+        inherits=(),
+        is_public=True,
+        underlying={"target": target, "key": key, "result": result},
+    )
+
+
+ItemGet = _make_item_get()

mixinv2_library-0.4.0.post31.dev0/tests/PythonOperatorTest.mixin.yaml

@@ -0,0 +1,126 @@
+# Binary arithmetic
+_threeAddFour:
+  - [Builtin, PythonOperator, Add]
+  - operand0: 3
+    operand1: 4
+addResult: [_threeAddFour, result]
+
+_tenSubtractThree:
+  - [Builtin, PythonOperator, Subtract]
+  - operand0: 10
+    operand1: 3
+subtractResult: [_tenSubtractThree, result]
+
+_fiveMultiplySix:
+  - [Builtin, PythonOperator, Multiply]
+  - operand0: 5
+    operand1: 6
+multiplyResult: [_fiveMultiplySix, result]
+
+_sevenTrueDivideTwo:
+  - [Builtin, PythonOperator, TrueDivide]
+  - operand0: 7
+    operand1: 2
+trueDivideResult: [_sevenTrueDivideTwo, result]
+
+_sevenFloorDivideTwo:
+  - [Builtin, PythonOperator, FloorDivide]
+  - operand0: 7
+    operand1: 2
+floorDivideResult: [_sevenFloorDivideTwo, result]
+
+_sevenModuloThree:
+  - [Builtin, PythonOperator, Modulo]
+  - operand0: 7
+    operand1: 3
+moduloResult: [_sevenModuloThree, result]
+
+_twoPowerThree:
+  - [Builtin, PythonOperator, Power]
+  - operand0: 2
+    operand1: 3
+powerResult: [_twoPowerThree, result]
+
+# Comparison
+_threeEqualThree:
+  - [Builtin, PythonOperator, Equal]
+  - operand0: 3
+    operand1: 3
+equalTrueResult: [_threeEqualThree, result]
+
+_threeEqualFour:
+  - [Builtin, PythonOperator, Equal]
+  - operand0: 3
+    operand1: 4
+equalFalseResult: [_threeEqualFour, result]
+
+_threeLessThanFour:
+  - [Builtin, PythonOperator, LessThan]
+  - operand0: 3
+    operand1: 4
+lessThanTrueResult: [_threeLessThanFour, result]
+
+_fourLessThanThree:
+  - [Builtin, PythonOperator, LessThan]
+  - operand0: 4
+    operand1: 3
+lessThanFalseResult: [_fourLessThanThree, result]
+
+# Unary
+_negateFive:
+  - [Builtin, PythonOperator, Negate]
+  - operand: 5
+negateResult: [_negateFive, result]
+
+_absoluteNegativeSeven:
+  - [Builtin, PythonOperator, Absolute]
+  - operand: -7
+absoluteResult: [_absoluteNegativeSeven, result]
+
+_truthZero:
+  - [Builtin, PythonOperator, Truth]
+  - operand: 0
+truthFalseResult: [_truthZero, result]
+
+_truthOne:
+  - [Builtin, PythonOperator, Truth]
+  - operand: 1
+truthTrueResult: [_truthOne, result]
+
+_logicalNotTrue:
+  - [Builtin, PythonOperator, LogicalNot]
+  - operand: true
+logicalNotResult: [_logicalNotTrue, result]
+
+# Bitwise
+_bitwiseAndResult:
+  - [Builtin, PythonOperator, BitwiseAnd]
+  - operand0: 0b1100
+    operand1: 0b1010
+bitwiseAndResult: [_bitwiseAndResult, result]
+
+_bitwiseOrResult:
+  - [Builtin, PythonOperator, BitwiseOr]
+  - operand0: 0b1100
+    operand1: 0b1010
+bitwiseOrResult: [_bitwiseOrResult, result]
+
+_leftShiftResult:
+  - [Builtin, PythonOperator, LeftShift]
+  - operand0: 1
+    operand1: 4
+leftShiftResult: [_leftShiftResult, result]
+
+# Sequence
+_concatResult:
+  - [Builtin, PythonOperator, Concatenate]
+  - operand0: "hello "
+    operand1: "world"
+concatResult: [_concatResult, result]
+
+# Higher-order: AttributeGet
+_attributeGetResult:
+  - [Builtin, PythonOperator, AttributeGet]
+  - target: "hello"
+    attributeName: "__class__"
+attributeGetResult: [_attributeGetResult, result]

mixinv2_library-0.4.0.post31.dev0/tests/test_python_operator.py

@@ -0,0 +1,136 @@
+"""Tests for Builtin.PythonOperator FFI wrappers.
+
+Verifies that the programmatically generated operator FFI scopes
+correctly wrap Python's operator module functions.
+"""
+
+from pathlib import Path
+
+import pytest
+
+import mixinv2_library
+from mixinv2._mixin_directory import DirectoryMixinDefinition
+from mixinv2._runtime import Scope, evaluate
+
+
+TESTS_PATH = Path(__file__).parent
+
+
+@pytest.fixture
+def operator_scope() -> Scope:
+    """Load and evaluate the PythonOperator test fixture."""
+    tests_definition = DirectoryMixinDefinition(
+        inherits=(), is_public=True, underlying=TESTS_PATH
+    )
+    root = evaluate(mixinv2_library, tests_definition, modules_public=True)
+    result = root.PythonOperatorTest
+    assert isinstance(result, Scope)
+    return result
+
+
+class TestBinaryArithmetic:
+    """Test binary arithmetic operators."""
+
+    def test_add(self, operator_scope: Scope) -> None:
+        """3 + 4 = 7"""
+        assert operator_scope.addResult == 7
+
+    def test_subtract(self, operator_scope: Scope) -> None:
+        """10 - 3 = 7"""
+        assert operator_scope.subtractResult == 7
+
+    def test_multiply(self, operator_scope: Scope) -> None:
+        """5 * 6 = 30"""
+        assert operator_scope.multiplyResult == 30
+
+    def test_true_divide(self, operator_scope: Scope) -> None:
+        """7 / 2 = 3.5"""
+        assert operator_scope.trueDivideResult == 3.5
+
+    def test_floor_divide(self, operator_scope: Scope) -> None:
+        """7 // 2 = 3"""
+        assert operator_scope.floorDivideResult == 3
+
+    def test_modulo(self, operator_scope: Scope) -> None:
+        """7 % 3 = 1"""
+        assert operator_scope.moduloResult == 1
+
+    def test_power(self, operator_scope: Scope) -> None:
+        """2 ** 3 = 8"""
+        assert operator_scope.powerResult == 8
+
+
+class TestComparison:
+    """Test comparison operators."""
+
+    def test_equal_true(self, operator_scope: Scope) -> None:
+        """3 == 3 is True"""
+        assert operator_scope.equalTrueResult is True
+
+    def test_equal_false(self, operator_scope: Scope) -> None:
+        """3 == 4 is False"""
+        assert operator_scope.equalFalseResult is False
+
+    def test_less_than_true(self, operator_scope: Scope) -> None:
+        """3 < 4 is True"""
+        assert operator_scope.lessThanTrueResult is True
+
+    def test_less_than_false(self, operator_scope: Scope) -> None:
+        """4 < 3 is False"""
+        assert operator_scope.lessThanFalseResult is False
+
+
+class TestUnary:
+    """Test unary operators."""
+
+    def test_negate(self, operator_scope: Scope) -> None:
+        """neg(5) = -5"""
+        assert operator_scope.negateResult == -5
+
+    def test_absolute(self, operator_scope: Scope) -> None:
+        """abs(-7) = 7"""
+        assert operator_scope.absoluteResult == 7
+
+    def test_truth_false(self, operator_scope: Scope) -> None:
+        """truth(0) is False"""
+        assert operator_scope.truthFalseResult is False
+
+    def test_truth_true(self, operator_scope: Scope) -> None:
+        """truth(1) is True"""
+        assert operator_scope.truthTrueResult is True
+
+    def test_logical_not(self, operator_scope: Scope) -> None:
+        """not_(True) is False"""
+        assert operator_scope.logicalNotResult is False
+
+
+class TestBitwise:
+    """Test bitwise operators."""
+
+    def test_bitwise_and(self, operator_scope: Scope) -> None:
+        """0b1100 & 0b1010 = 0b1000 = 8"""
+        assert operator_scope.bitwiseAndResult == 0b1000
+
+    def test_bitwise_or(self, operator_scope: Scope) -> None:
+        """0b1100 | 0b1010 = 0b1110 = 14"""
+        assert operator_scope.bitwiseOrResult == 0b1110
+
+    def test_left_shift(self, operator_scope: Scope) -> None:
+        """1 << 4 = 16"""
+        assert operator_scope.leftShiftResult == 16
+
+
+class TestSequence:
+    """Test sequence operators."""
+
+    def test_concatenate(self, operator_scope: Scope) -> None:
+        """'hello ' + 'world' = 'hello world'"""
+        assert operator_scope.concatResult == "hello world"
+
+
+class TestHigherOrder:
+    """Test higher-order operators."""
+
+    def test_attribute_get(self, operator_scope: Scope) -> None:
+        """'hello'.__class__ is str"""
+        assert operator_scope.attributeGetResult is str