tinycwrap 0.0.4__tar.gz → 0.0.6__tar.gz

{tinycwrap-0.0.4 → tinycwrap-0.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tinycwrap
-Version: 0.0.4
+Version: 0.0.6
 Summary: Lightweight C-to-Python wrapper generator using CFFI and NumPy
 Author: TinyCWrap Contributors
 Requires-Python: >=3.9

{tinycwrap-0.0.4 → tinycwrap-0.0.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tinycwrap"
-version = "0.0.4"
+version = "0.0.6"
 description = "Lightweight C-to-Python wrapper generator using CFFI and NumPy"
 readme = "README.md"
 requires-python = ">=3.9"

tinycwrap-0.0.4/tests/test_examples.py → tinycwrap-0.0.6/tests/test_kernels.py

@@ -14,9 +14,9 @@ def cm():
 
 
 def test_dot(cm):
-    x = np.arange(10, dtype=np.float64)
-    y = np.ones_like(x)
-    assert cm.dot(x, y, len_x=len(x)) == np.sum(x * y)
+    x = np.array([1.0, 2.0, 3.0], dtype=np.float64)
+    y = np.array([4.0, 5.0, 6.0], dtype=np.float64)
+    assert cm.dot(x, y, len_x=len(x)) == np.dot(x, y)
 
 
 def test_scale_auto_output(cm):

{tinycwrap-0.0.4 → tinycwrap-0.0.6}/tests/test_path.py

@@ -52,3 +52,7 @@ def test_repr_pointer_array(cp):
     repr_str = repr(path)
     assert "segments=<segments* 0x" in repr_str
     assert "len_segments=2" in repr_str
+
+def test_post_contract(cp):
+    segments, len_segments = cp.geom2d_segments_from_rectellipse(1,2,3,4)
+    assert segments.shape == (4,)

{tinycwrap-0.0.4 → tinycwrap-0.0.6}/tinycwrap/__init__.py

@@ -6,6 +6,6 @@ from .cmodule import CModule
 try:
     __version__ = version("tinycwrap")
 except PackageNotFoundError:
-    __version__ = "0.0.4"
+    __version__ = "0.0.6"
 
 __all__ = ["CModule", "__version__"]

{tinycwrap-0.0.4 → tinycwrap-0.0.6}/tinycwrap/cmodule.py

@@ -381,24 +381,22 @@ class CModule:
             fspec.doc = doc
             contracts = []
             for line in doc.splitlines():
-                if "Contract:" in line or "Post-Contract:" in line:
-                    after = (
-                        line.split("Contract:", 1)[1]
-                        if "Contract:" in line
-                        else line.split("Post-Contract:", 1)[1]
-                    )
-                    is_post = "Post-Contract" in line
-                    for part in after.split(";"):
-                        part = part.strip()
-                        if not part:
-                            continue
-                        mlen = re.match(r"len\((\w+)\)\s*=\s*(.+)", part)
-                        if not mlen:
-                            mlen = re.match(r"(\w+)\s*=\s*(.+)", part)
-                        if mlen:
-                            target = mlen.group(1)
-                            expr = mlen.group(2).strip()
-                            contracts.append((target, expr, is_post))
+                m_contract = re.search(r"(post-)?contract:\s*(.*)", line, flags=re.IGNORECASE)
+                if not m_contract:
+                    continue
+                is_post = m_contract.group(1) is not None
+                after = m_contract.group(2)
+                for part in after.split(";"):
+                    part = part.strip()
+                    if not part:
+                        continue
+                    mlen = re.match(r"len\((\w+)\)\s*=\s*(.+)", part)
+                    if not mlen:
+                        mlen = re.match(r"(\w+)\s*=\s*(.+)", part)
+                    if mlen:
+                        target = mlen.group(1)
+                        expr = mlen.group(2).strip()
+                        contracts.append((target, expr, is_post))
             fspec.contracts = contracts or None
 
     def _mark_length_params_from_contracts(self):
@@ -430,13 +428,14 @@ class CModule:
                         "size_t",
                         "ssize_t",
                     )
-                    and (not arg.is_pointer)
                     and arg.name in referenced
                 ):
                     arg.is_length_param = True
             for arg in fspec.args:
                 if arg.is_length_param:
                     arg.is_scalar = False
+                    arg.is_array_in = False
+                    arg.is_array_out = False
                 elif (
                     (not arg.is_pointer)
                     and arg.array_len is None
@@ -496,7 +495,15 @@ class CModule:
                             target_dtype = _struct_dtypes.get(f.base_type)
                             provided = kwargs.get(f.name)
                             if provided is not None and target_dtype is not None:
-                                arr = np.ascontiguousarray(provided, dtype=target_dtype)
+                                try:
+                                    arr = np.ascontiguousarray(provided, dtype=target_dtype)
+                                except ValueError:
+                                    if hasattr(provided, "_data"):
+                                        arr = np.ascontiguousarray(provided._data, dtype=target_dtype)
+                                    elif isinstance(provided, (list, tuple)) and provided and hasattr(provided[0], "_data"):
+                                        arr = np.ascontiguousarray([p._data for p in provided], dtype=target_dtype)
+                                    else:
+                                        raise
                                 children[f.name] = arr
                                 data[f.name] = arr.ctypes.data
                                 if len_field in dtype.names and len_field not in kwargs:
@@ -747,6 +754,7 @@ class CModule:
                 else:
                     contract_map[target] = expr
 
+        length_pointer_names = {a.name for a in fspec.args if a.is_length_param and a.is_pointer}
         pointer_scalar_names = {
             a.name
             for a in fspec.args
@@ -767,7 +775,7 @@ class CModule:
                     "ssize_t",
                 )
             )
-        }
+        } | length_pointer_names
 
         func_names = set(self._func_specs.keys())
 
@@ -776,6 +784,7 @@ class CModule:
             expr = re.sub(r"len\((\w+)\)", r"len(arr_\1)", expr)
             for name in pointer_scalar_names:
                 expr = re.sub(rf"\b{name}\b", f"int(arr_{name}.ravel()[0])", expr)
+                expr = re.sub(rf"\b{name}\b", f"scalar_{name}", expr)
             if func_names:
                 pattern = r"\b(" + "|".join(re.escape(n) for n in func_names) + r")\s*\(([^()]*)\)"
 
@@ -803,6 +812,17 @@ class CModule:
         scalar_lines: list[str] = []
 
         for a in fspec.args:
+            if a.is_length_param and a.is_pointer:
+                base_dtype = "np.dtype('int32')"
+                out_lines = [
+                    f"    arr_{a.name} = np.zeros((), dtype={base_dtype})",
+                    f"    ptr_{a.name} = _self._ffi.cast('{a.base_type} *', _self._ffi.from_buffer(arr_{a.name}))",
+                ]
+                call_args.append(f"ptr_{a.name}")
+                output_vars.append(f"arr_{a.name}")
+                output_names.append(a.name)
+                pointer_scalar_outputs.append((a.name, f"arr_{a.name}"))
+                continue
             if a.is_array_in:
                 const_prefix = "const " if a.is_const else ""
                 if a.base_type in struct_names:
@@ -834,21 +854,25 @@ class CModule:
                 scalar_lines.append(f"    {a.name} = {a.name}")
                 call_args.append(a.name)
             elif a.is_length_param:
-                if a.name in contract_map:
-                    expr_py = _expr_py(contract_map[a.name])
-                    length_lines += [
-                        f"    if {a.name} is None:",
-                        f"        {a.name} = int({expr_py})",
-                        f"    else:",
-                        f"        {a.name} = int({a.name})",
-                    ]
+                if a.is_pointer:
+                    # handled in array/pointer branch
+                    call_args.append(None)
                 else:
-                    length_lines += [
-                        f"    if {a.name} is None:",
-                        f"        raise ValueError('{fspec.name}: length parameter {a.name} requires an explicit Contract')",
-                        f"    {a.name} = int({a.name})",
-                    ]
-                call_args.append(a.name)
+                    if a.name in contract_map:
+                        expr_py = _expr_py(contract_map[a.name])
+                        length_lines += [
+                            f"    if {a.name} is None:",
+                            f"        {a.name} = int({expr_py})",
+                            f"    else:",
+                            f"        {a.name} = int({a.name})",
+                        ]
+                    else:
+                        length_lines += [
+                            f"    if {a.name} is None:",
+                            f"        raise ValueError('{fspec.name}: length parameter {a.name} requires an explicit Contract')",
+                            f"    {a.name} = int({a.name})",
+                        ]
+                    call_args.append(a.name)
             else:
                 # defer outputs / pointer handling
                 call_args.append(None)  # placeholder
@@ -954,11 +978,6 @@ class CModule:
         else:
             lines.append(f"    res = {call_expr}")
 
-        for out_name, out_var in zip(output_names, output_vars):
-            if out_name in post_contract_map:
-                expr_py = _expr_py(post_contract_map[out_name])
-                lines.append(f"    {out_var} = {out_var}[:int({expr_py})]")
-
         for name, arr_var in pointer_scalar_outputs:
             lines.append(f"    scalar_{name} = int(np.asarray({arr_var}).ravel()[0])")
 
@@ -966,11 +985,19 @@ class CModule:
         for name, arr_var, cls_expr in struct_scalar_outputs:
             lines.append(f"    obj_{name} = {cls_expr}()")
             lines.append(f"    object.__setattr__(obj_{name}, '_data', np.array({arr_var}, copy=True))")
+        pointer_scalar_map = {arr: (name, f"scalar_{name}") for name, arr in pointer_scalar_outputs}
+        pairs = list(zip(output_names, output_vars))
+        # place array outputs before scalar pointer lengths
+        pairs_sorted = sorted(pairs, key=lambda p: 1 if p[1] in pointer_scalar_map else 0)
+        output_names_reordered: list[str] = []
         output_vars_final: list[str] = []
-        for ov in output_vars:
+        for name, ov in pairs_sorted:
+            output_names_reordered.append(name)
             if ov in struct_scalar_map:
                 n, _ = struct_scalar_map[ov]
                 output_vars_final.append(f"obj_{n}")
+            elif ov in pointer_scalar_map:
+                output_vars_final.append(pointer_scalar_map[ov][1])
             else:
                 output_vars_final.append(ov)
 
@@ -985,8 +1012,20 @@ class CModule:
                     ret_expr = f"{output_vars_final[0]}, res"
                 else:
                     ret_expr = "(" + ", ".join(output_vars_final) + "), res"
+            # apply post-contract slicing using scalar lengths if available
+            for out_name, out_var in zip(output_names_reordered, output_vars_final):
+                if out_name in post_contract_map:
+                    expr_py = _expr_py(post_contract_map[out_name])
+                    scalar_names = {n for n, _ in pointer_scalar_outputs}
+                    if out_name in scalar_names:
+                        expr_py = expr_py.replace(out_name, f"scalar_{out_name}")
+                    ret_expr = ret_expr.replace(out_var, f"({out_var})[:int({expr_py})]")
             if pointer_scalar_outputs:
-                scalars = [f"scalar_{n}" for n, _ in pointer_scalar_outputs]
+                scalars = [
+                    f"scalar_{n}"
+                    for n, _ in pointer_scalar_outputs
+                    if f"scalar_{n}" not in output_vars_final
+                ]
                 if isinstance(ret_expr, str) and ret_expr.startswith("("):
                     ret_expr = (
                         ret_expr[:-1]

{tinycwrap-0.0.4 → tinycwrap-0.0.6}/tinycwrap.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tinycwrap
-Version: 0.0.4
+Version: 0.0.6
 Summary: Lightweight C-to-Python wrapper generator using CFFI and NumPy
 Author: TinyCWrap Contributors
 Requires-Python: >=3.9

{tinycwrap-0.0.4 → tinycwrap-0.0.6}/tinycwrap.egg-info/SOURCES.txt

@@ -1,7 +1,7 @@
 README.md
 pyproject.toml
-tests/test_examples.py
 tests/test_geom.py
+tests/test_kernels.py
 tests/test_path.py
 tinycwrap/__init__.py
 tinycwrap/cmodule.py