tinycwrap 0.1.1__tar.gz → 0.1.2__tar.gz

{tinycwrap-0.1.1 → tinycwrap-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tinycwrap
-Version: 0.1.1
+Version: 0.1.2
 Summary: Lightweight C-to-Python wrapper generator using CFFI and NumPy
 Author: TinyCWrap Contributors
 Requires-Python: >=3.9
@@ -28,9 +28,7 @@ Write a small C file (only non-`static` functions are exported):
 ```c
 /* kernels.c */
 double dot(const double *x, const double *y, int len_x)
-/* Return dot product between x and y
-   Contract: len_x=len(x);
-*/
+/* Return dot product between x and y */
 {
     double acc = 0.0;
     for (int i = 0; i < len_x; ++i)
@@ -50,7 +48,7 @@ cm = CModule("kernels.c")  # builds the shared library, creates wrappers
 x = np.arange(5, dtype=np.float64)
 y = np.ones_like(x)
 
-cm.dot(x, y)           # -> 10.0, len_x auto-filled by the contract
+cm.dot(x, y)           # -> 10.0, len_x auto-filled by convention
 print(cm.dot.__doc__)  # docstring comes from the C comment
 ```
 
@@ -65,7 +63,7 @@ TinyCWrap infers how to build wrappers from simple C conventions:
   - `T *arg` -> output/in-place array (prefer naming it `out_*` when possible).
   - `T arg[N]` in the signature -> fixed-size array (input if `const`, otherwise output).
   - Plain scalars (`double`, `int`, ...) -> Python scalars.
-- **Length parameters**: integers such as `len_x`, `n`, `size_x` can be auto-filled if you declare a contract (see below). Otherwise pass them explicitly from Python.
+- **Length parameters**: integers named like `len_x`, `n_x`, or `size_x` are auto-filled from array `x` by convention. Otherwise pass them explicitly from Python or declare a contract (see below).
 - **Docstrings**: the block comment immediately after the function header becomes the Python docstring.
 - **Structs**: `typedef struct { ... } Name;` definitions in your headers/sources become Python classes with a `.dtype` and NumPy-backed storage.
 - **Compilation**: extra sources can be passed (`CModule("main.c", "helper.c")`), and extra include dirs via `include_dirs=[...]`. Default compiler flags are `-O3 -shared -fPIC -march=native -mtune=native` plus the NumPy include path.
@@ -79,6 +77,15 @@ Contracts are declared inside the doc comment with `Contract:` (or `Contracts:`)
 - `len(out)=len_x` — allocate a 1D output array.
 - `postlen(out)=out_len` — slice the output after the call using an integer pointer result `out_len` (useful when the C code writes less than the allocated length).
 - `own(return)` — the returned pointer is owned by the caller; the wrapper will `free` it after copying to NumPy (requires a `len(return)=...` contract).
+- `expose(len_x)` — opt out of naming-convention inference for `len_x`, keeping it as a required Python argument.
+
+TinyCWrap also infers low-risk contracts from names:
+
+- `len_x`, `n_x`, or `size_x` are treated as `len(x)` when `x` is an array argument.
+- `out_x` is allocated with `shape(x)` when input array `x` exists.
+- `out_x` is allocated with `len_x`, `n_x`, or `size_x` when no input `x` exists but such a length argument does.
+
+Explicit contracts override inferred contracts.
 
 Examples pulled from the test suite:
 
@@ -109,9 +116,9 @@ Rules are parsed case-insensitively; whitespace does not matter.
 
 ## Python wrapper behavior
 
-- **Automatic allocation**: any `out_*` argument defaults to `None` in Python; TinyCWrap allocates it based on contracts, fixed array sizes, or by matching the shape of a related input (`out_x` matches `x` when no contract is present).
+- **Automatic allocation**: any `out_*` argument defaults to `None` in Python; TinyCWrap allocates it based on contracts, naming conventions, fixed array sizes, or by matching the shape of a related input (`out_x` matches `x` when no contract is present).
 - **Struct pointer outputs**: non-const struct pointers are treated as in/out; when you pass an object/array explicitly, it is mutated in place and not returned. When you pass `None`, TinyCWrap allocates and returns the struct (or struct array).
-- **Optional length arguments**: integer length parameters inferred from contracts default to `None` in the wrapper signature. If you pass them, they are cast to `int`; if not, the expression from the contract is evaluated.
+- **Optional length arguments**: integer length parameters inferred from contracts or naming conventions default to `None` in the wrapper signature. If you pass them, they are cast to `int`; if not, the inferred expression is evaluated.
 - **Post contracts**: when a contract uses `postlen(...)` or `post shape(...)`, the wrapper slices/reshapes outputs after the C call using the values written by the C function.
 - **Scalar pointer outputs**: pointers to integer-like types (e.g., `int *out_len`) are returned as plain Python integers alongside other outputs.
 - **Structs**: for `typedef struct` declarations TinyCWrap generates a Python class:
@@ -174,7 +181,7 @@ arr, n = cm.alloc_random_array()  # returns NumPy array, frees the C buffer
 ## Tips
 
 - Keep function declarations (or headers) visible at the top level; TinyCWrap scans the C files and headers you pass.
-- If a length cannot be inferred from a contract, you must pass it explicitly from Python.
+- If a length cannot be inferred from a naming convention or contract, you must pass it explicitly from Python.
 - Use `cm.<func>.__source__` to inspect the wrapper code if something behaves unexpectedly.
 - For debugging parsed signatures/contracts call `cm._debug_specs()`.
 

{tinycwrap-0.1.1 → tinycwrap-0.1.2}/README.md

@@ -18,9 +18,7 @@ Write a small C file (only non-`static` functions are exported):
 ```c
 /* kernels.c */
 double dot(const double *x, const double *y, int len_x)
-/* Return dot product between x and y
-   Contract: len_x=len(x);
-*/
+/* Return dot product between x and y */
 {
     double acc = 0.0;
     for (int i = 0; i < len_x; ++i)
@@ -40,7 +38,7 @@ cm = CModule("kernels.c")  # builds the shared library, creates wrappers
 x = np.arange(5, dtype=np.float64)
 y = np.ones_like(x)
 
-cm.dot(x, y)           # -> 10.0, len_x auto-filled by the contract
+cm.dot(x, y)           # -> 10.0, len_x auto-filled by convention
 print(cm.dot.__doc__)  # docstring comes from the C comment
 ```
 
@@ -55,7 +53,7 @@ TinyCWrap infers how to build wrappers from simple C conventions:
   - `T *arg` -> output/in-place array (prefer naming it `out_*` when possible).
   - `T arg[N]` in the signature -> fixed-size array (input if `const`, otherwise output).
   - Plain scalars (`double`, `int`, ...) -> Python scalars.
-- **Length parameters**: integers such as `len_x`, `n`, `size_x` can be auto-filled if you declare a contract (see below). Otherwise pass them explicitly from Python.
+- **Length parameters**: integers named like `len_x`, `n_x`, or `size_x` are auto-filled from array `x` by convention. Otherwise pass them explicitly from Python or declare a contract (see below).
 - **Docstrings**: the block comment immediately after the function header becomes the Python docstring.
 - **Structs**: `typedef struct { ... } Name;` definitions in your headers/sources become Python classes with a `.dtype` and NumPy-backed storage.
 - **Compilation**: extra sources can be passed (`CModule("main.c", "helper.c")`), and extra include dirs via `include_dirs=[...]`. Default compiler flags are `-O3 -shared -fPIC -march=native -mtune=native` plus the NumPy include path.
@@ -69,6 +67,15 @@ Contracts are declared inside the doc comment with `Contract:` (or `Contracts:`)
 - `len(out)=len_x` — allocate a 1D output array.
 - `postlen(out)=out_len` — slice the output after the call using an integer pointer result `out_len` (useful when the C code writes less than the allocated length).
 - `own(return)` — the returned pointer is owned by the caller; the wrapper will `free` it after copying to NumPy (requires a `len(return)=...` contract).
+- `expose(len_x)` — opt out of naming-convention inference for `len_x`, keeping it as a required Python argument.
+
+TinyCWrap also infers low-risk contracts from names:
+
+- `len_x`, `n_x`, or `size_x` are treated as `len(x)` when `x` is an array argument.
+- `out_x` is allocated with `shape(x)` when input array `x` exists.
+- `out_x` is allocated with `len_x`, `n_x`, or `size_x` when no input `x` exists but such a length argument does.
+
+Explicit contracts override inferred contracts.
 
 Examples pulled from the test suite:
 
@@ -99,9 +106,9 @@ Rules are parsed case-insensitively; whitespace does not matter.
 
 ## Python wrapper behavior
 
-- **Automatic allocation**: any `out_*` argument defaults to `None` in Python; TinyCWrap allocates it based on contracts, fixed array sizes, or by matching the shape of a related input (`out_x` matches `x` when no contract is present).
+- **Automatic allocation**: any `out_*` argument defaults to `None` in Python; TinyCWrap allocates it based on contracts, naming conventions, fixed array sizes, or by matching the shape of a related input (`out_x` matches `x` when no contract is present).
 - **Struct pointer outputs**: non-const struct pointers are treated as in/out; when you pass an object/array explicitly, it is mutated in place and not returned. When you pass `None`, TinyCWrap allocates and returns the struct (or struct array).
-- **Optional length arguments**: integer length parameters inferred from contracts default to `None` in the wrapper signature. If you pass them, they are cast to `int`; if not, the expression from the contract is evaluated.
+- **Optional length arguments**: integer length parameters inferred from contracts or naming conventions default to `None` in the wrapper signature. If you pass them, they are cast to `int`; if not, the inferred expression is evaluated.
 - **Post contracts**: when a contract uses `postlen(...)` or `post shape(...)`, the wrapper slices/reshapes outputs after the C call using the values written by the C function.
 - **Scalar pointer outputs**: pointers to integer-like types (e.g., `int *out_len`) are returned as plain Python integers alongside other outputs.
 - **Structs**: for `typedef struct` declarations TinyCWrap generates a Python class:
@@ -164,7 +171,7 @@ arr, n = cm.alloc_random_array()  # returns NumPy array, frees the C buffer
 ## Tips
 
 - Keep function declarations (or headers) visible at the top level; TinyCWrap scans the C files and headers you pass.
-- If a length cannot be inferred from a contract, you must pass it explicitly from Python.
+- If a length cannot be inferred from a naming convention or contract, you must pass it explicitly from Python.
 - Use `cm.<func>.__source__` to inspect the wrapper code if something behaves unexpectedly.
 - For debugging parsed signatures/contracts call `cm._debug_specs()`.
 

{tinycwrap-0.1.1 → tinycwrap-0.1.2}/pyproject.toml

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

{tinycwrap-0.1.1 → tinycwrap-0.1.2}/tests/test_kernels.py

@@ -16,23 +16,30 @@ def cm():
 def test_dot(cm):
     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)
+    assert cm.dot(x, y) == np.dot(x, y)
 
 
 def test_scale_auto_output(cm):
     x = np.arange(10, dtype=np.float64)
-    scaled_auto = cm.scale(x, 1.1, len_x=len(x))
+    scaled_auto = cm.scale(x, 1.1)
     np.testing.assert_allclose(scaled_auto, x * 1.1)
 
 
 def test_scale_explicit_output(cm):
     x = np.arange(10, dtype=np.float64)
     out = np.empty_like(x)
-    scaled_explicit = cm.scale(x, 2.0, len_x=len(x), out_x=out)
+    scaled_explicit = cm.scale(x, 2.0, out_x=out)
     np.testing.assert_allclose(out, x * 2.0)
     np.testing.assert_allclose(scaled_explicit, x * 2.0)
 
 
+def test_expose_keeps_inferred_length_visible(cm):
+    x = np.arange(5, dtype=np.float64)
+    assert cm.prefix_sum(x, len_x=3) == 3.0
+    with pytest.raises(TypeError):
+        cm.prefix_sum(x)
+
+
 def test_mat_add_shape_contract(cm):
     a = np.arange(6, dtype=np.float64).reshape(2, 3)
     b = np.ones_like(a)
@@ -129,7 +136,7 @@ def test_struct_array_argument(cm):
     particles["vel"][0] = [1.0, 0.0, 0.0]
     particles["pos"][1] = [0.0, 0.0, 0.0]
     particles["vel"][1] = [0.0, 2.0, 0.0]
-    ke = cm.kinetic_energy(particles, len_p=len(particles))
+    ke = cm.kinetic_energy(particles)
     assert np.isclose(ke, 0.5 * (1.0 + 4.0))
 
 

{tinycwrap-0.1.1 → tinycwrap-0.1.2}/tinycwrap/__init__.py

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

{tinycwrap-0.1.1 → tinycwrap-0.1.2}/tinycwrap/cmodule.py

@@ -169,6 +169,7 @@ class CModule:
         self._func_specs.pop("free", None)
         self._struct_specs = parse_structs_from_cdef(self._cdef)
         self._attach_docs_from_source()
+        self._infer_contracts_from_names()
         self._mark_length_params_from_contracts()
         self._create_struct_classes()
         self._create_wrappers()
@@ -448,6 +449,7 @@ class CModule:
             fspec.doc = doc
             contracts = []
             owns: list[str] = []
+            exposes: set[str] = set()
 
             def _normalize_shape_expr(expr: str) -> str:
                 expr = expr.strip()
@@ -483,6 +485,13 @@ class CModule:
                         if n:
                             owns.append(n)
                     continue
+                m_expose_call = re.match(r"expose\s*\(\s*([^)]+)\s*\)\s*$", entry, flags=re.IGNORECASE)
+                if m_expose_call:
+                    for name in m_expose_call.group(1).split(","):
+                        n = name.strip()
+                        if n:
+                            exposes.add(n)
+                    continue
                 is_post = False
                 m_post = re.match(r"post\s*(.+)", entry, flags=re.IGNORECASE)
                 if m_post and (m_post.group(1).strip().lower().startswith("len(") or m_post.group(1).strip().lower().startswith("shape(")):
@@ -515,6 +524,84 @@ class CModule:
                     contracts.append((target, expr, is_post))
             fspec.contracts = contracts or None
             fspec.owns = owns or None
+            fspec.exposes = exposes or None
+
+    @staticmethod
+    def _length_arg_target(arg_name: str) -> str | None:
+        for prefix in ("len_", "n_", "size_"):
+            if arg_name.startswith(prefix) and len(arg_name) > len(prefix):
+                return arg_name[len(prefix) :]
+        return None
+
+    @staticmethod
+    def _is_integer_arg(arg) -> bool:
+        return arg.base_type in (
+            "int",
+            "unsigned int",
+            "unsigned",
+            "long",
+            "long int",
+            "long long",
+            "long long int",
+            "unsigned long",
+            "unsigned long long",
+            "size_t",
+            "ssize_t",
+        )
+
+    def _infer_contracts_from_names(self):
+        """Infer low-risk contracts from conventional argument names."""
+        for fspec in self._func_specs.values():
+            contracts = list(fspec.contracts or [])
+            exposes = fspec.exposes or set()
+            explicit_targets = {target for target, _expr, _is_post in contracts}
+            explicit_shapes = {
+                target[len("shape(") : -1]
+                for target, _expr, _is_post in contracts
+                if target.startswith("shape(") and target.endswith(")")
+            }
+            arg_by_name = {a.name: a for a in fspec.args}
+            array_names = {
+                a.name
+                for a in fspec.args
+                if a.is_array_in or a.is_array_out or a.is_pointer or a.array_len is not None
+            }
+
+            for arg in fspec.args:
+                if arg.name in exposes or not self._is_integer_arg(arg):
+                    continue
+                target = self._length_arg_target(arg.name)
+                if target and target in array_names and arg.name not in explicit_targets:
+                    contracts.append((arg.name, f"len({target})", False))
+                    explicit_targets.add(arg.name)
+
+            length_names_by_target: dict[str, str] = {}
+            for arg in fspec.args:
+                target = self._length_arg_target(arg.name)
+                if target and self._is_integer_arg(arg):
+                    length_names_by_target[target] = arg.name
+
+            for arg in fspec.args:
+                if not (arg.is_array_out and arg.name.lower().startswith("out_")):
+                    continue
+                target = arg.name[4:]
+                if arg.name in explicit_targets or arg.name in explicit_shapes:
+                    continue
+                if target in arg_by_name and (
+                    arg_by_name[target].is_array_in
+                    or arg_by_name[target].is_array_out
+                    or arg_by_name[target].is_pointer
+                    or arg_by_name[target].array_len is not None
+                ):
+                    contracts.append((f"shape({arg.name})", f"shape({target})", False))
+                    explicit_shapes.add(arg.name)
+                    continue
+                length_name = length_names_by_target.get(target)
+                if length_name:
+                    contracts.append((arg.name, length_name, False))
+                    explicit_targets.add(arg.name)
+
+            fspec.contracts = contracts or None
 
     def _mark_length_params_from_contracts(self):
         """Mark length-like parameters based solely on explicit contracts."""
@@ -981,7 +1068,7 @@ class CModule:
             if a.is_array_out and a.name.lower().startswith("out"):
                 extra.append("auto if None")
             if a.is_length_param:
-                extra.append("auto from Contract")
+                extra.append("auto")
             extra_txt = f" [{' '.join(extra)}]" if extra else ""
             arg_docs.append(f"{a.name} : {ctype} ({role}){extra_txt}")
 
@@ -1194,22 +1281,23 @@ class CModule:
                     out_lines += [
                         f"        arr_{a.name} = np.zeros(int({expr_py}), dtype=base_dtype)"
                     ]
-                elif a.array_len is None and len_expr is None and shape_expr is None:
-                    out_lines += [
-                        f"        arr_{a.name} = np.zeros((), dtype=base_dtype)"
-                    ]
                 elif ref_name:
                     out_lines += [
                         f"        ref_arr = locals().get('arr_{ref_name}', None)",
                         "        if ref_arr is not None:",
                         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')",
+                        f"            arr_{a.name} = np.zeros((), dtype=base_dtype)",
                     ]
                 else:
-                    out_lines += [
-                        f"        raise ValueError('{fspec.name}: provide {a.name} or a Contract for its length')",
-                    ]
+                    if a.array_len is None and len_expr is None and shape_expr is None:
+                        out_lines += [
+                            f"        arr_{a.name} = np.zeros((), dtype=base_dtype)"
+                        ]
+                    else:
+                        out_lines += [
+                            f"        raise ValueError('{fspec.name}: provide {a.name} or a Contract for its length')",
+                        ]
                 out_lines += [
                     "    else:",
                 ]

{tinycwrap-0.1.1 → tinycwrap-0.1.2}/tinycwrap/parsing.py

@@ -73,6 +73,7 @@ class FuncSpec:
     doc: str | None = None
     contracts: list[tuple[str, str, bool]] | None = None
     owns: list[str] | None = None
+    exposes: set[str] | None = None
 
 
 @dataclass

{tinycwrap-0.1.1 → tinycwrap-0.1.2}/tinycwrap.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tinycwrap
-Version: 0.1.1
+Version: 0.1.2
 Summary: Lightweight C-to-Python wrapper generator using CFFI and NumPy
 Author: TinyCWrap Contributors
 Requires-Python: >=3.9
@@ -28,9 +28,7 @@ Write a small C file (only non-`static` functions are exported):
 ```c
 /* kernels.c */
 double dot(const double *x, const double *y, int len_x)
-/* Return dot product between x and y
-   Contract: len_x=len(x);
-*/
+/* Return dot product between x and y */
 {
     double acc = 0.0;
     for (int i = 0; i < len_x; ++i)
@@ -50,7 +48,7 @@ cm = CModule("kernels.c")  # builds the shared library, creates wrappers
 x = np.arange(5, dtype=np.float64)
 y = np.ones_like(x)
 
-cm.dot(x, y)           # -> 10.0, len_x auto-filled by the contract
+cm.dot(x, y)           # -> 10.0, len_x auto-filled by convention
 print(cm.dot.__doc__)  # docstring comes from the C comment
 ```
 
@@ -65,7 +63,7 @@ TinyCWrap infers how to build wrappers from simple C conventions:
   - `T *arg` -> output/in-place array (prefer naming it `out_*` when possible).
   - `T arg[N]` in the signature -> fixed-size array (input if `const`, otherwise output).
   - Plain scalars (`double`, `int`, ...) -> Python scalars.
-- **Length parameters**: integers such as `len_x`, `n`, `size_x` can be auto-filled if you declare a contract (see below). Otherwise pass them explicitly from Python.
+- **Length parameters**: integers named like `len_x`, `n_x`, or `size_x` are auto-filled from array `x` by convention. Otherwise pass them explicitly from Python or declare a contract (see below).
 - **Docstrings**: the block comment immediately after the function header becomes the Python docstring.
 - **Structs**: `typedef struct { ... } Name;` definitions in your headers/sources become Python classes with a `.dtype` and NumPy-backed storage.
 - **Compilation**: extra sources can be passed (`CModule("main.c", "helper.c")`), and extra include dirs via `include_dirs=[...]`. Default compiler flags are `-O3 -shared -fPIC -march=native -mtune=native` plus the NumPy include path.
@@ -79,6 +77,15 @@ Contracts are declared inside the doc comment with `Contract:` (or `Contracts:`)
 - `len(out)=len_x` — allocate a 1D output array.
 - `postlen(out)=out_len` — slice the output after the call using an integer pointer result `out_len` (useful when the C code writes less than the allocated length).
 - `own(return)` — the returned pointer is owned by the caller; the wrapper will `free` it after copying to NumPy (requires a `len(return)=...` contract).
+- `expose(len_x)` — opt out of naming-convention inference for `len_x`, keeping it as a required Python argument.
+
+TinyCWrap also infers low-risk contracts from names:
+
+- `len_x`, `n_x`, or `size_x` are treated as `len(x)` when `x` is an array argument.
+- `out_x` is allocated with `shape(x)` when input array `x` exists.
+- `out_x` is allocated with `len_x`, `n_x`, or `size_x` when no input `x` exists but such a length argument does.
+
+Explicit contracts override inferred contracts.
 
 Examples pulled from the test suite:
 
@@ -109,9 +116,9 @@ Rules are parsed case-insensitively; whitespace does not matter.
 
 ## Python wrapper behavior
 
-- **Automatic allocation**: any `out_*` argument defaults to `None` in Python; TinyCWrap allocates it based on contracts, fixed array sizes, or by matching the shape of a related input (`out_x` matches `x` when no contract is present).
+- **Automatic allocation**: any `out_*` argument defaults to `None` in Python; TinyCWrap allocates it based on contracts, naming conventions, fixed array sizes, or by matching the shape of a related input (`out_x` matches `x` when no contract is present).
 - **Struct pointer outputs**: non-const struct pointers are treated as in/out; when you pass an object/array explicitly, it is mutated in place and not returned. When you pass `None`, TinyCWrap allocates and returns the struct (or struct array).
-- **Optional length arguments**: integer length parameters inferred from contracts default to `None` in the wrapper signature. If you pass them, they are cast to `int`; if not, the expression from the contract is evaluated.
+- **Optional length arguments**: integer length parameters inferred from contracts or naming conventions default to `None` in the wrapper signature. If you pass them, they are cast to `int`; if not, the inferred expression is evaluated.
 - **Post contracts**: when a contract uses `postlen(...)` or `post shape(...)`, the wrapper slices/reshapes outputs after the C call using the values written by the C function.
 - **Scalar pointer outputs**: pointers to integer-like types (e.g., `int *out_len`) are returned as plain Python integers alongside other outputs.
 - **Structs**: for `typedef struct` declarations TinyCWrap generates a Python class:
@@ -174,7 +181,7 @@ arr, n = cm.alloc_random_array()  # returns NumPy array, frees the C buffer
 ## Tips
 
 - Keep function declarations (or headers) visible at the top level; TinyCWrap scans the C files and headers you pass.
-- If a length cannot be inferred from a contract, you must pass it explicitly from Python.
+- If a length cannot be inferred from a naming convention or contract, you must pass it explicitly from Python.
 - Use `cm.<func>.__source__` to inspect the wrapper code if something behaves unexpectedly.
 - For debugging parsed signatures/contracts call `cm._debug_specs()`.