tinycwrap 0.0.1__tar.gz → 0.0.3__tar.gz

{tinycwrap-0.0.1 → tinycwrap-0.0.3}/PKG-INFO

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

{tinycwrap-0.0.1 → tinycwrap-0.0.3}/pyproject.toml

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

{tinycwrap-0.0.1 → tinycwrap-0.0.3}/tests/test_geom.py

@@ -40,4 +40,24 @@ def test_geom2d_return_strct(cg):
     assert seg.data[0] == 0.1
     assert seg.data[1] == 0.2
     assert np.isclose(seg.data[2], 0.1+0.3*0.5)
-    assert np.isclose(seg.data[3], 0.2+0.4*0.3)
+    assert np.isclose(seg.data[3], 0.2+0.4*0.3)
+
+
+def test_geom2d_return_strct_array_member(cg):
+    seg = cg.geom2d_rectangle_to_path(1,2)
+    assert len(seg) == 4
+
+
+def test_docstring_contains_contract(cg):
+    doc = cg.geom2d_rectangle_to_path.__doc__
+    assert "Contract: len(out_segments)=4" in doc
+    assert "Auto-wrapped C function `geom2d_rectangle_to_path`." in doc
+
+
+def test_polygon_length(cg):
+    pts = cg.G2DPoints(len_points=3)
+    pts.points[0]["x"] = 0.0; pts.points[0]["y"] = 0.0
+    pts.points[1]["x"] = 1.0; pts.points[1]["y"] = 0.0
+    pts.points[2]["x"] = 1.0; pts.points[2]["y"] = 1.0
+    length = cg.geom2d_polygon_length(pts.points)
+    assert length == 2.0

tinycwrap-0.0.3/tests/test_path.py

@@ -0,0 +1,41 @@
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+from tinycwrap import CModule
+
+
+@pytest.fixture(scope="module")
+def cp():
+    return CModule(Path("tests/t1/base.c"), Path("tests/t1/path.c"))
+
+
+def test_path_get_steps_contract(cp):
+    seg = cp.G2DSegment()
+    # line from (0,0) to (1,0)
+    seg.type = 0
+    seg.data = [0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0]
+    segments = np.array([seg._data], dtype=cp.G2DSegment.dtype)
+    steps = cp.geom2d_path_get_steps(segments, ds_min=0.25)
+    expected_len = cp.geom2d_path_get_len_steps(segments, len_segments=len(segments), ds_min=0.25)
+    assert len(steps) == expected_len
+    assert np.isclose(steps[-1], cp.geom2d_path_get_length(segments, len_segments=1))
+
+
+def test_path_struct_pointer_array(cp):
+    path = cp.G2DPath(len_segments=3)
+    assert path.len_segments == 3
+    assert isinstance(path.segments, np.ndarray)
+    assert path.segments.shape == (3,)
+    assert path.segments.dtype == cp.G2DSegment.dtype
+
+
+def test_return_class_path(cp):
+    path=cp.G2DPath(len_segments=1)
+    cp.geom2d_path_from_circle(1.0, path)
+    assert path.len_segments == 1
+    assert path.segments.shape == (1,)
+    seg = path.segments[0]
+    assert seg['type'] == 1  # circle segment
+    np.testing.assert_allclose(seg['data'][:3], [0.0, 0.0, 1.0])  # cx,cy,radius

{tinycwrap-0.0.1 → tinycwrap-0.0.3}/tinycwrap/__init__.py

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

{tinycwrap-0.0.1 → tinycwrap-0.0.3}/tinycwrap/cmodule.py

@@ -53,6 +53,7 @@ class CModule:
         compiler="gcc",
         compile_args=None,
         reload=True,
+        verbose=False,
     ):
         """
         Parameters
@@ -69,6 +70,8 @@ class CModule:
         reload : bool, default True
             If True and running inside IPython, register a pre-run-cell hook to auto-recompile
             when the C source changes.
+        verbose : bool, default False
+            If True, print compilation and parsing details.
         """
         if not c_sources:
             raise ValueError("At least one C source path is required")
@@ -80,6 +83,7 @@ class CModule:
             "compile_args": compile_args
             or ["-O3", "-shared", "-fPIC", "-march=native", "-mtune=native"],
         }
+        self._verbose = verbose
 
         self._ffi = None
         self._lib = None
@@ -136,12 +140,13 @@ class CModule:
             cmd.extend(["-I", str(inc)])
 
         # regenerate cdef from source
-        self._cdef = self._generate_cdef_from_source(verbose=self._cdef is None)
+        self._cdef = self._generate_cdef_from_source(verbose=self._verbose)
 
         sources = [str(self._c_path), *(str(p) for p in self._extra_sources)]
         cmd.extend(["-o", str(so_path), *sources])
 
-        print(f"[CModule] Compiling: {' '.join(cmd)}")
+        if self._verbose:
+            print(f"[CModule] Compiling: {' '.join(cmd)}")
         subprocess.run(cmd, check=True)
 
         ffi = FFI()
@@ -153,7 +158,8 @@ class CModule:
         self._sig = sig
         self._so_path = so_path
 
-        print(f"[CModule] Loaded {so_path}")
+        if self._verbose:
+            print(f"[CModule] Loaded {so_path}")
 
         # Re-parse cdef and attach docs from C source, then create wrappers
         self._func_specs = parse_functions_from_cdef(self._cdef)
@@ -187,6 +193,23 @@ class CModule:
             self._so_path = None
             self._compile_and_load()
 
+    def _debug_specs(self):
+        """Return a pretty string of parsed function specs and contracts (for debugging)."""
+        lines: list[str] = []
+        for name, spec in self._func_specs.items():
+            arg_lines = [f"    {a.raw_ctype} {a.name}" for a in spec.args]
+            if arg_lines:
+                lines.append(f"{name}")
+                lines.extend(arg_lines)
+                lines.append(f"    -> {spec.return_ctype}")
+            else:
+                lines.append(f"{name}() -> {spec.return_ctype}")
+            if spec.contracts:
+                for target, expr, is_post in spec.contracts:
+                    prefix = "Post-Contract" if is_post else "Contract"
+                    lines.append(f"    {prefix}: {target} = {expr}")
+        print("\n".join(lines))
+
     # ---------- IPython auto-reload hook ------------------------------------
 
     def _register_ipython_autoreload(self):
@@ -230,7 +253,7 @@ class CModule:
 
     # ---------- 1) auto-generate cdef from C source -------------------------
 
-    def _generate_cdef_from_source(self, verbose: bool = True) -> str:
+    def _generate_cdef_from_source(self, verbose: bool | None = None) -> str:
         """
         Parse the C file and auto-generate a minimal cdef string.
 
@@ -334,21 +357,21 @@ class CModule:
                 continue
             cdef_lines.append(line)
         cdef = "\n".join(cdef_lines)
-        if verbose:
+        show = self._verbose if verbose is None else verbose
+        if show:
             print("[CModule] Auto-generated cdef:\n" + cdef)
         return cdef
 
     # ---------- 2) parse cdef -> FuncSpec/ArgSpec ---------------------------
 
     def _attach_docs_from_source(self):
-        try:
-            src = self._c_path.read_text(encoding="utf8")
-        except OSError:
+        src = self._combined_source()
+        if not src:
             return
 
         for fname, fspec in self._func_specs.items():
-            # we look for: name ( ... ) /* ... */
-            pattern = rf"{re.escape(fname)}\s*\([^{{;]*\)\s*/\*(.*?)\*/"
+            # we look for: name ( ... ) [optional brace] /* ... */
+            pattern = rf"{re.escape(fname)}\s*\([^{{;]*\)\s*\{{?\s*/\*(.*?)\*/"
             m = re.search(pattern, src, flags=re.DOTALL)
             if not m:
                 continue
@@ -439,8 +462,19 @@ class CModule:
         for sname, sspec in self._struct_specs.items():
             try:
                 dtype_fields = []
+                pointer_meta = []
                 for f in sspec.fields:
-                    base_dtype = numpy_dtype_for_base_type(f.base_type)
+                    try:
+                        base_dtype = numpy_dtype_for_base_type(f.base_type)
+                    except TypeError:
+                        base_dtype = None
+                    if f.is_pointer:
+                        dtype_fields.append((f.name, np.uintp))
+                        pointer_meta.append(f)
+                        if base_dtype is None:
+                            continue
+                    if base_dtype is None:
+                        continue
                     if f.array_len:
                         dtype_fields.append((f.name, (base_dtype, (f.array_len,))))
                     else:
@@ -449,15 +483,35 @@ class CModule:
             except TypeError:
                 continue
 
-            def make_struct_class(spec, dtype):
-                slots = ("_data",)
+            def make_struct_class(spec, dtype, _struct_dtypes=self._struct_dtypes):
+                slots = ("_data", "_children")
 
                 def __init__(self, **kwargs):
                     data = np.zeros((), dtype=dtype)
+                    children = {}
+                    # handle pointer+len convention
+                    for f in spec.fields:
+                        if f.is_pointer and f.name in dtype.names:
+                            len_field = f"len_{f.name}"
+                            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)
+                                children[f.name] = arr
+                                data[f.name] = arr.ctypes.data
+                                if len_field in dtype.names and len_field not in kwargs:
+                                    data[len_field] = len(arr)
+                            elif len_field in kwargs and target_dtype is not None:
+                                llen = int(kwargs[len_field])
+                                arr = np.zeros(llen, dtype=target_dtype)
+                                children[f.name] = arr
+                                data[f.name] = arr.ctypes.data
+                                data[len_field] = llen
                     for k in dtype.names:
                         if k in kwargs:
                             data[k] = kwargs[k]
                     object.__setattr__(self, "_data", data)
+                    object.__setattr__(self, "_children", children)
 
                 def __repr__(self):
                     parts_list = []
@@ -485,7 +539,9 @@ class CModule:
                     field_info = dtype.fields[fname][0]
                     is_scalar = field_info.shape == ()
 
-                    def getter(self, fname=fname, is_scalar=is_scalar):
+                    def getter(self, fname=fname, is_scalar=is_scalar, field_info=field_info):
+                        if fname in getattr(self, "_children", {}):
+                            return self._children[fname]
                         val = self._data[fname]
                         return val.item() if is_scalar else val
 
@@ -496,6 +552,11 @@ class CModule:
                         field_info=field_info,
                         is_scalar=is_scalar,
                     ):
+                        if fname in getattr(self, "_children", {}):
+                            arr = np.ascontiguousarray(value, dtype=self._children[fname].dtype)
+                            self._children[fname] = arr
+                            self._data[fname] = arr.ctypes.data
+                            return
                         if is_scalar:
                             self._data[fname] = value
                         else:
@@ -550,7 +611,7 @@ class CModule:
         wrapper = namespace[fspec.name]
         wrapper.__source__ = src
         try:
-            wrapper.__c_source__ = self._c_path.read_text(encoding="utf8")
+            wrapper.__c_source__ = self._function_source(fspec.name) or self._combined_source()
         except OSError:
             wrapper.__c_source__ = None
         return wrapper
@@ -560,10 +621,13 @@ class CModule:
         Build the Python source string for a wrapper with an explicit signature.
         Keeping this separate allows inspection/debugging of the generated code.
         """
-        try:
-            c_source_text = self._c_path.read_text(encoding="utf8")
-        except OSError:
-            c_source_text = None
+        src_parts: list[str] = []
+        func_text = self._function_source(fspec.name)
+        if func_text:
+            c_source_text = func_text
+        else:
+            combined = self._combined_source()
+            c_source_text = combined if combined else None
 
         struct_names = set(self._struct_specs.keys())
         params: list[str] = []
@@ -662,11 +726,27 @@ class CModule:
             )
         }
 
+        func_names = set(self._func_specs.keys())
+
         def _expr_py(expr: str) -> str:
             expr = expr.strip()
             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)
+            if func_names:
+                pattern = r"\b(" + "|".join(re.escape(n) for n in func_names) + r")\s*\(([^()]*)\)"
+
+                def _repl(m):
+                    fname = m.group(1)
+                    spec = self._func_specs.get(fname)
+                    if not spec:
+                        return m.group(0)
+                    call_parts = []
+                    for arg in spec.args:
+                        call_parts.append(f"{arg.name}={arg.name}")
+                    return f"_self.{fname}(" + ", ".join(call_parts) + ")"
+
+                expr = re.sub(pattern, _repl, expr)
             return expr
 
         call_args: list[str] = []
@@ -746,12 +826,12 @@ class CModule:
                 ]
                 if a.array_len is not None:
                     out_lines += [
-                        f"        arr_{a.name} = np.empty({int(a.array_len)}, dtype=base_dtype)"
+                        f"        arr_{a.name} = np.zeros({int(a.array_len)}, dtype=base_dtype)"
                     ]
                 elif a.name in contract_map:
                     expr_py = _expr_py(contract_map[a.name])
                     out_lines += [
-                        f"        arr_{a.name} = np.empty(int({expr_py}), dtype=base_dtype)"
+                        f"        arr_{a.name} = np.zeros(int({expr_py}), dtype=base_dtype)"
                     ]
                 elif a.array_len is None and a.name not in contract_map:
                     out_lines += [
@@ -761,7 +841,7 @@ class CModule:
                     out_lines += [
                         f"        ref_arr = locals().get('arr_{ref_name}', None)",
                         "        if ref_arr is not None:",
-                        f"            arr_{a.name} = np.empty_like(ref_arr, dtype=base_dtype)",
+                        f"            arr_{a.name} = np.zeros_like(ref_arr, dtype=base_dtype)",
                         "        else:",
                         f"            raise ValueError('{fspec.name}: provide {a.name} or a Contract for its length')",
                     ]
@@ -912,3 +992,36 @@ class CModule:
                 lines.append(f"    return {ret_expr}")
 
         return "\n".join(lines)
+
+    def _combined_source(self) -> str:
+        texts: list[str] = []
+        for path in [self._c_path, *self._extra_sources]:
+            try:
+                texts.append(path.read_text(encoding="utf8"))
+            except OSError:
+                continue
+        return "\n".join(texts)
+
+    def _function_source(self, fname: str) -> str | None:
+        """Return the source (including body) of the given C function if found."""
+        src = self._combined_source()
+        if not src:
+            return None
+        pattern = re.compile(
+            rf"([\w\s\*\r\n]+{re.escape(fname)}\s*\([^{{;]*\))\s*(?:/\*.*?\*/\s*)?\{{",
+            re.DOTALL,
+        )
+        m = pattern.search(src)
+        if not m:
+            return None
+        brace_start = m.end() - 1
+        depth = 0
+        for idx in range(brace_start, len(src)):
+            ch = src[idx]
+            if ch == "{":
+                depth += 1
+            elif ch == "}":
+                depth -= 1
+                if depth == 0:
+                    return src[m.start() : idx + 1]
+        return None

{tinycwrap-0.0.1 → tinycwrap-0.0.3}/tinycwrap/parsing.py

@@ -200,10 +200,6 @@ def _parse_structs_with_pycparser(cdef: str) -> dict[str, StructSpec]:
                 for decl in struct.decls:
                     ctype, is_ptr, is_const, arr_len = _ctype_from_decl(decl.type)
                     base = base_type_from_ctype(ctype)
-                    try:
-                        numpy_dtype_for_base_type(base)
-                    except TypeError:
-                        continue
                     fields.append(
                         StructField(
                             name=decl.name,
@@ -311,7 +307,7 @@ def _parse_structs_regex(cdef: str) -> dict[str, StructSpec]:
             if not line:
                 continue
             line = re.sub(r"/\*.*?\*/", "", line).strip()
-            m_field = re.match(r"(.+?)\s+([A-Za-z_]\w*)(\s*\[(\d+)\])?$", line)
+            m_field = re.match(r"(.+?\*?)\s*([A-Za-z_]\w*)(\s*\[(\d+)\])?$", line)
             if not m_field:
                 continue
             raw_ctype = m_field.group(1).strip()
@@ -320,10 +316,6 @@ def _parse_structs_regex(cdef: str) -> dict[str, StructSpec]:
             is_pointer = "*" in raw_ctype
             is_const = "const" in raw_ctype
             base = base_type_from_ctype(raw_ctype)
-            try:
-                numpy_dtype_for_base_type(base)
-            except TypeError:
-                continue
             fields.append(
                 StructField(
                     name=fname,

{tinycwrap-0.0.1 → tinycwrap-0.0.3}/tinycwrap.egg-info/PKG-INFO

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

{tinycwrap-0.0.1 → tinycwrap-0.0.3}/tinycwrap.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ README.md
 pyproject.toml
 tests/test_examples.py
 tests/test_geom.py
+tests/test_path.py
 tinycwrap/__init__.py
 tinycwrap/cmodule.py
 tinycwrap/parsing.py