tinycwrap 0.0.1__tar.gz → 0.0.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tinycwrap
-Version: 0.0.1
+Version: 0.0.2
 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.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tinycwrap"
-version = "0.0.1"
+version = "0.0.2"
 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.2}/tests/test_geom.py

@@ -40,4 +40,15 @@ 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

tinycwrap-0.0.2/tests/test_path.py

@@ -0,0 +1,23 @@
+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))

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

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

{tinycwrap-0.0.1 → tinycwrap-0.0.2}/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
@@ -550,7 +573,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 +583,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 +688,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 +788,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 +803,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 +954,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.2}/tinycwrap.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tinycwrap
-Version: 0.0.1
+Version: 0.0.2
 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.2}/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