PyPI - tinycwrap - Versions diffs - 0.0.5__tar.gz → 0.0.7__tar.gz - Mend

tinycwrap 0.0.5tar.gz → 0.0.7tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

{tinycwrap-0.0.5 → tinycwrap-0.0.7}/PKG-INFO RENAMED Viewed

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

{tinycwrap-0.0.5 → tinycwrap-0.0.7}/pyproject.toml RENAMED Viewed

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

{tinycwrap-0.0.5 → tinycwrap-0.0.7}/tests/test_kernels.py RENAMED Viewed

@@ -88,6 +88,13 @@ def test_merge_sorted(cm):
     assert out_len_val == 4
+def test_owned_array(cm):
+    arr, n = cm.alloc_random_array()
+    assert arr.shape[0] == n
+    assert n >= 3
+    assert np.all(arr[:n] >= 1.0)
 def test_struct_output_array(cm):
     n = 4
     particles = cm.Particle.zeros(n)

{tinycwrap-0.0.5 → tinycwrap-0.0.7}/tinycwrap/__init__.py RENAMED Viewed

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

{tinycwrap-0.0.5 → tinycwrap-0.0.7}/tinycwrap/cmodule.py RENAMED Viewed

@@ -11,6 +11,7 @@ from cffi import FFI
 from .parsing import (
     FuncSpec,
     StructSpec,
+    base_type_from_ctype,
     numpy_dtype_for_base_type,
     parse_functions_from_cdef,
     parse_structs_from_cdef,
@@ -163,6 +164,8 @@ class CModule:
         # Re-parse cdef and attach docs from C source, then create wrappers
         self._func_specs = parse_functions_from_cdef(self._cdef)
+        # remove helper prototypes we add for ownership
+        self._func_specs.pop("free", None)
         self._struct_specs = parse_structs_from_cdef(self._cdef)
         self._attach_docs_from_source()
         self._mark_length_params_from_contracts()
@@ -287,6 +290,21 @@ class CModule:
         src_wo_pp = re.sub(r"__declspec\s*\([^)]+\)", "", src_wo_pp)
         src_wo_pp = re.sub(r"__asm__\s*\([^)]*\)", "", src_wo_pp)
+        # Keep a version with only top-level text (brace depth 0) to avoid
+        # picking up statements inside function bodies.
+        top_level_chars = []
+        depth = 0
+        for ch in src_wo_pp:
+            if ch == "{":
+                depth += 1
+            if depth == 0:
+                top_level_chars.append(ch)
+            if ch == "}" and depth > 0:
+                depth -= 1
+                if depth == 0:
+                    top_level_chars.append("\n")
+        top_level_src = "".join(top_level_chars)
         # regex for function definitions
         func_def_re = re.compile(
             r"""
@@ -311,11 +329,15 @@ class CModule:
             r"typedef\s+struct\s+(?:\w+\s*)?{(?P<body>[^}]*)}\s*(?P<name>\w+)\s*;",
             re.DOTALL,
         )
+        seen_structs = set()
         for m in struct_re.finditer(src_wo_pp):
-            struct_text = m.group(0)
-            struct_defs.append(struct_text.strip())
+            struct_text = m.group(0).strip()
+            if struct_text not in seen_structs:
+                struct_defs.append(struct_text)
+                seen_structs.add(struct_text)
         proto_set = set()
+        proto_name_set = set()
         for m in func_def_re.finditer(src_wo_pp):
             if m.group("prefix") and "static" in m.group("prefix"):
                 # ignore static functions, not exported
@@ -339,12 +361,46 @@ class CModule:
                 continue
             args = " ".join(strip_restrict_keywords(m.group("args")).split())
             proto = f"{ret} {name}({args});"
-            if proto not in proto_set:
+            if name not in proto_name_set:
+                prototypes.append(proto)
+                proto_set.add(proto)
+                proto_name_set.add(name)
+        # also pick up function declarations (without body), e.g., from headers
+        decl_re = re.compile(r"([A-Za-z_][A-Za-z0-9_\s\*]*?)\s+([A-Za-z_]\w*)\s*\(([^)]*)\)\s*;")
+        for m in decl_re.finditer(top_level_src):
+            if "return" in m.group(0) or "=" in m.group(0):
+                continue
+            ret = " ".join(strip_restrict_keywords(m.group(1)).split())
+            if "static" in ret.split():
+                continue
+            name = m.group(2)
+            args = " ".join(strip_restrict_keywords(m.group(3)).split())
+            proto = f"{ret} {name}({args});"
+            if name not in proto_name_set:
                 prototypes.append(proto)
                 proto_set.add(proto)
+                proto_name_set.add(name)
         if not prototypes and not struct_defs:
             raise RuntimeError(f"No functions found in {self._c_path} to generate cdef")
+        # fallback: if we missed pointer-returning prototypes present as lines
+        type_prefix_re = re.compile(r"^(void|int|float|double|long|unsigned|signed|struct|char)\b")
+        for line in top_level_src.splitlines():
+            line_clean = line.strip()
+            if not line_clean or line_clean.startswith("typedef") or ":" in line_clean:
+                continue
+            if not type_prefix_re.match(line_clean):
+                continue
+            if "=" in line_clean:
+                continue
+            if "(" in line_clean and ")" in line_clean and line_clean.endswith(";"):
+                name_match = re.match(r"[A-Za-z_][A-Za-z0-9_\s\*]*?\s+([A-Za-z_]\w*)\s*\(", line_clean)
+                fname = name_match.group(1) if name_match else line_clean
+                if fname not in proto_name_set:
+                    prototypes.append(line_clean)
+                    proto_set.add(line_clean)
+                    proto_name_set.add(fname)
         cdef_parts = []
         if struct_defs:
@@ -357,6 +413,8 @@ class CModule:
                 continue
             cdef_lines.append(line)
         cdef = "\n".join(cdef_lines)
+        if "free(" not in cdef:
+            cdef += "\nvoid free(void *);"
         show = self._verbose if verbose is None else verbose
         if show:
             print("[CModule] Auto-generated cdef:\n" + cdef)
@@ -380,9 +438,16 @@ class CModule:
             doc = re.sub(r"\n\s+", "\n", doc)
             fspec.doc = doc
             contracts = []
+            owns: list[str] = []
             for line in doc.splitlines():
                 m_contract = re.search(r"(post-)?contract:\s*(.*)", line, flags=re.IGNORECASE)
                 if not m_contract:
+                    m_own = re.search(r"own:\s*(.*)", line, flags=re.IGNORECASE)
+                    if m_own:
+                        for name in m_own.group(1).split(","):
+                            n = name.strip()
+                            if n:
+                                owns.append(n)
                     continue
                 is_post = m_contract.group(1) is not None
                 after = m_contract.group(2)
@@ -398,6 +463,7 @@ class CModule:
                         expr = mlen.group(2).strip()
                         contracts.append((target, expr, is_post))
             fspec.contracts = contracts or None
+            fspec.owns = owns or None
     def _mark_length_params_from_contracts(self):
         """Mark length-like parameters based solely on explicit contracts."""
@@ -428,13 +494,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
@@ -639,6 +706,7 @@ class CModule:
             "_self": self,
             "np": np,
             "numpy_dtype_for_base_type": numpy_dtype_for_base_type,
+            "base_type_from_ctype": base_type_from_ctype,
             "_struct_classes": self._struct_classes,
             "_struct_dtypes": self._struct_dtypes,
         }
@@ -664,7 +732,6 @@ class CModule:
         Build the Python source string for a wrapper with an explicit signature.
         Keeping this separate allows inspection/debugging of the generated code.
         """
-        src_parts: list[str] = []
         func_text = self._function_source(fspec.name)
         if func_text:
             c_source_text = func_text
@@ -753,6 +820,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
@@ -773,7 +841,7 @@ class CModule:
                     "ssize_t",
                 )
             )
-        }
+        } | length_pointer_names
         func_names = set(self._func_specs.keys())
@@ -782,6 +850,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*\(([^()]*)\)"
@@ -809,6 +878,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:
@@ -840,21 +920,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
@@ -955,15 +1039,14 @@ class CModule:
         ret_type = fspec.return_ctype.strip()
         call_expr = f"cfun({', '.join(arg_call_args)})"
-        if ret_type == "void":
-            lines.append(f"    {call_expr}")
+        own_return = fspec.owns and "return" in fspec.owns and fspec.return_ctype.strip().endswith("*")
+        if own_return:
+            lines.append(f"    res_ptr = {call_expr}")
         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})]")
+            if ret_type == "void":
+                lines.append(f"    {call_expr}")
+            else:
+                lines.append(f"    res = {call_expr}")
         for name, arr_var in pointer_scalar_outputs:
             lines.append(f"    scalar_{name} = int(np.asarray({arr_var}).ravel()[0])")
@@ -972,14 +1055,73 @@ 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)
+        own_return_len_expr = None
+        if own_return and contract_map.get("return"):
+            own_return_len_expr = _expr_py(contract_map["return"])
+        if own_return:
+            base_ret = base_type_from_ctype(fspec.return_ctype)
+            ret_dtype_expr = f"np.dtype('{np.dtype(numpy_dtype_for_base_type(base_ret)).name}')"
+            lines.append("    lib_free = None")
+            lines.append("    try:")
+            lines.append("        lib_free = _self._lib.free")
+            lines.append("    except AttributeError:")
+            lines.append("        pass")
+            lines.append("    libc_free = None")
+            lines.append("    for _cand in (None, 'libc.so.6', 'libc.so', 'libc.dylib'):")
+            lines.append("        if libc_free is not None:")
+            lines.append("            break")
+            lines.append("        try:")
+            lines.append("            _libc = _self._ffi.dlopen(_cand)")
+            lines.append("            libc_free = getattr(_libc, 'free', None)")
+            lines.append("        except OSError:")
+            lines.append("            continue")
+            lines.append("    free_fn = lib_free or libc_free")
+            lines.append(f"    if free_fn is None: raise RuntimeError('{fspec.name}: cannot locate free() for owned return')")
+            if own_return_len_expr is None:
+                lines.append(f"    raise ValueError('{fspec.name}: Own return requires len(return)=... Contract')")
+            else:
+                for name, arr_var in pointer_scalar_outputs:
+                    if f"scalar_{name}" not in [v for v in output_vars_final]:
+                        lines.append(f"    scalar_{name} = int(np.asarray({arr_var}).ravel()[0])")
+                # allow len(return)=out_len style expressions that use pointer-scalar values
+                lines.append(f"    res_buf = _self._ffi.gc(res_ptr, free_fn)")
+                lines.append(
+                    f"    arr_ret = np.frombuffer(_self._ffi.buffer(res_buf, int({own_return_len_expr}) * np.dtype({ret_dtype_expr}).itemsize), dtype={ret_dtype_expr})"
+                )
+            ret_parts: list[str] = ["arr_ret"]
+            if output_vars_final:
+                for v in output_vars_final:
+                    if v not in ret_parts:
+                        ret_parts.append(v)
+            # append any scalar lengths not already in ret_parts
+            for name, _arr in pointer_scalar_outputs:
+                sval = f"scalar_{name}"
+                if sval not in ret_parts:
+                    ret_parts.append(sval)
+            if len(ret_parts) == 1:
+                ret_expr = ret_parts[0]
+            else:
+                ret_expr = "(" + ", ".join(ret_parts) + ")"
+            lines.append(f"    return {ret_expr}")
+            return "\n".join(lines)
         if output_vars_final:
             if ret_type == "void":
                 if len(output_vars_final) == 1:
@@ -991,8 +1133,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.5 → tinycwrap-0.0.7}/tinycwrap/parsing.py RENAMED Viewed

@@ -72,6 +72,7 @@ class FuncSpec:
     args: list   # list[ArgSpec]
     doc: str | None = None
     contracts: list[tuple[str, str, bool]] | None = None
+    owns: list[str] | None = None
 @dataclass
@@ -151,7 +152,9 @@ def _parse_functions_with_pycparser(cdef: str) -> dict[str, FuncSpec]:
     for ext in ast.ext:
         if isinstance(ext, c_ast.Decl) and isinstance(ext.type, c_ast.FuncDecl):
             fname = ext.name
-            ret_ctype, _, _, _ = _ctype_from_decl(ext.type.type)
+            ret_ctype, ret_is_ptr, _, _ = _ctype_from_decl(ext.type.type)
+            if ret_is_ptr:
+                ret_ctype = ret_ctype + " *"
             argspecs: list[ArgSpec] = []
             args = ext.type.args
             if args and args.params:

{tinycwrap-0.0.5 → tinycwrap-0.0.7}/tinycwrap.egg-info/PKG-INFO RENAMED Viewed

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