sig-light 0.2.4__tar.gz

sig_light-0.2.4/.github/workflows/cicd.yml

@@ -0,0 +1,52 @@
+name: CICD
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6.0.2
+        with:
+          persist-credentials: false
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@cec208311dfd045dd5311c1add060b2062131d57  # v8.0.0
+        with:
+          python-version: ${{ matrix.python-version }}
+          enable-cache: true
+          cache-dependency-glob: |
+            **/pyproject.toml
+            **/uv.lock
+
+      - name: Install dependencies
+        run: uv sync --all-extras --group dev
+
+      - name: Lint
+        run: uv run ruff check .
+
+      - name: Format check
+        run: uv run ruff format --check .
+
+      - name: Type check
+        run: uv run ty check
+
+      - name: Run tests with coverage
+        run: uv run pytest -v --cov=src --cov-report=term-missing --cov-report=xml tests/
+
+      - name: Upload coverage reports to Codecov
+        if: matrix.python-version == '3.14'
+        uses: codecov/codecov-action@75cd11691c0faa626561e295848008c8a7dddffe  # v5
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}

sig_light-0.2.4/.github/workflows/publish.yml

@@ -0,0 +1,37 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags:
+      - v*
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+      contents: read
+    steps:
+      - name: Checkout
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6.0.2
+        with:
+          persist-credentials: false
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@cec208311dfd045dd5311c1add060b2062131d57  # v8.0.0
+        with:
+          python-version: "3.13"
+          enable-cache: false
+
+      - name: Build
+        run: uv build
+
+      - name: Smoke test (wheel)
+        run: uv run --isolated --no-project --with dist/*.whl -- python -c "import sig_light; print(sig_light.version())"
+
+      - name: Smoke test (sdist)
+        run: uv run --isolated --no-project --with dist/*.tar.gz -- python -c "import sig_light; print(sig_light.version())"
+
+      - name: Publish
+        run: uv publish

sig_light-0.2.4/.gitignore

@@ -0,0 +1,185 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+.python-version
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+# .python-version
+
+# pipenv
+# Pipfile.lock
+
+# UV
+# uv.lock
+
+# poetry
+# poetry.lock
+# poetry.toml
+
+# pdm
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+# pixi.lock
+.pixi
+
+# PEP 582
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+# .idea/
+
+# Abstra
+.abstra/
+
+# Visual Studio Code
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml

sig_light-0.2.4/CLAUDE.md

@@ -0,0 +1,58 @@
+# CLAUDE.md
+
+## Project Overview
+
+sig-light is a pure-Python library for computing path signatures and log signatures of multidimensional time series. It mirrors the iisignature API using Chen's identity over piecewise-linear paths with truncated tensor algebra operations. No C extensions — numpy only.
+
+## Key Commands
+
+```bash
+just sync       # Install dependencies
+just test       # Run all tests
+just test-cov   # Run tests with coverage
+just check      # Run all code quality checks (lint + format + typecheck)
+just lint       # Run ruff check
+just format     # Auto-format code
+just typecheck  # Run ty check
+just bench      # Run benchmark
+```
+
+## Architecture
+
+### Core Algorithm
+
+- Signature via Chen's identity: segment signatures (truncated exp) composed via tensor multiplication
+- Log signature via "S" method: compute signature, take tensor logarithm, project to Lyndon basis
+- Backpropagation via adjoint operations on tensor algebra primitives
+- All tensor algebra operations work on "level-lists": list of m arrays, level[k] has shape (d^(k+1),)
+- Batched operations use einsum for vectorized computation across segments
+
+### File Structure
+
+```
+src/sig_light/
+  __init__.py       # Public API re-exports, version()
+  algebra.py        # Tensor algebra: multiply, exp, log, adjoints, batched ops
+  signature.py      # sig(), siglength(), sigcombine(), format=2, batching
+  logsignature.py   # logsig(), logsiglength(), prepare(), basis(), batching
+  backprop.py       # sigbackprop(), sigjacobian(), logsigbackprop()
+  transforms.py     # sigjoin(), sigscale() + backprop variants
+  lyndon.py         # Lyndon word generation, bracketing, basis construction
+  rotational.py     # rotinv2d functions for 2D rotation-invariant features
+```
+
+### Key Types
+
+- **Level-list**: `list[NDArray]` of length m, representing truncated tensor algebra element (implicit 1 or 0 at level 0 depending on context)
+- **PreparedData**: frozen dataclass from `prepare()`, holds precomputed Lyndon basis info
+- **RotInv2DPreparedData**: frozen dataclass for rotation invariant computation
+- **Flat signature**: 1D ndarray of length `siglength(d, m)`, levels 1..m concatenated
+
+## Dependencies
+
+- numpy >= 2.0 (core computation)
+- Dev: ruff, ty, pytest, pytest-cov
+
+## API Compatibility
+
+Mirrors iisignature API. Signature does NOT include level 0 ("1") — starts from level 1, matching iisignature convention. All public functions support batching via extra leading dimensions.

sig_light-0.2.4/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yousif Toama
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sig_light-0.2.4/PKG-INFO

@@ -0,0 +1,227 @@
+Metadata-Version: 2.4
+Name: sig-light
+Version: 0.2.4
+Summary: Pure-Python path signature and log signature computation
+License-Expression: MIT
+License-File: LICENSE.md
+Requires-Python: >=3.10
+Requires-Dist: numpy>=2.0
+Description-Content-Type: text/markdown
+
+# sig-light
+
+[![CICD](https://github.com/yousif-toama/sig-light/actions/workflows/cicd.yml/badge.svg)](https://github.com/yousif-toama/sig-light/actions/workflows/cicd.yml)
+[![codecov](https://codecov.io/gh/yousif-toama/sig-light/graph/badge.svg)](https://codecov.io/gh/yousif-toama/sig-light)
+
+Pure-Python path signature and log signature computation, mirroring the [iisignature](https://github.com/bottler/iisignature) API.
+
+sig-light computes signatures and log signatures of multidimensional piecewise-linear paths using Chen's identity and truncated tensor algebra operations. No C extensions or compilation required — just numpy.
+
+## Installation
+
+```bash
+pip install sig-light
+```
+
+Or with uv:
+
+```bash
+uv add sig-light
+```
+
+## Quick Start
+
+```python
+import numpy as np
+import sig_light
+
+# Define a 2D path
+path = np.array([[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [0.0, 1.0], [0.0, 0.0]])
+
+# Compute signature at depth 3
+signature = sig_light.sig(path, 3)
+
+# Compute log signature
+s = sig_light.prepare(2, 3)
+log_signature = sig_light.logsig(path, s)
+
+# Backpropagation
+deriv = np.ones_like(signature)
+grad = sig_light.sigbackprop(deriv, path, 3)  # gradient w.r.t. path
+
+# Batching: process multiple paths at once
+paths = np.random.randn(10, 50, 2)  # 10 paths, 50 points, 2D
+sigs = sig_light.sig(paths, 3)  # shape (10, siglength(2, 3))
+```
+
+## API Reference
+
+### Signature
+
+#### `sig(path, m, format=0)`
+
+Compute the signature of a path truncated at depth `m`.
+
+- **path**: numpy array of shape `(..., n, d)`. Extra leading dims are batched.
+- **m**: truncation depth (positive integer).
+- **format**: output format.
+  - `0`: flat array of shape `(..., siglength(d, m))`.
+  - `1`: list of `m` arrays, one per level.
+  - `2`: cumulative prefix signatures, shape `(..., n-1, siglength(d, m))`.
+- **Returns**: the path signature, excluding the level-0 term (always 1).
+
+#### `siglength(d, m)`
+
+Length of the signature output: `d + d^2 + ... + d^m`.
+
+#### `sigcombine(sig1, sig2, d, m)`
+
+Combine two signatures via Chen's identity. Supports batching.
+
+### Backpropagation
+
+#### `sigbackprop(deriv, path, m)`
+
+Compute gradient of a loss w.r.t. the path, given gradient w.r.t. the signature.
+
+- **deriv**: shape `(..., siglength(d, m))`.
+- **path**: shape `(..., n, d)`.
+- **Returns**: shape `(..., n, d)`.
+
+#### `sigjacobian(path, m)`
+
+Full Jacobian matrix of `sig()` w.r.t. the path.
+
+- **Returns**: shape `(n, d, siglength(d, m))`.
+
+#### `logsigbackprop(deriv, path, s)`
+
+Compute gradient of a loss w.r.t. the path, given gradient w.r.t. the log signature.
+
+- **deriv**: shape `(..., logsiglength(d, m))`.
+- **path**: shape `(..., n, d)`.
+- **s**: prepared data from `prepare(d, m)`.
+- **Returns**: shape `(..., n, d)`.
+
+### Log Signature
+
+#### `prepare(d, m)`
+
+Precompute data for log signature computation.
+
+#### `logsig(path, s)`
+
+Compute the log signature in the Lyndon basis. Supports batching.
+
+#### `logsig_expanded(path, s)`
+
+Compute the log signature in the full tensor expansion. Supports batching.
+
+#### `logsiglength(d, m)`
+
+Length of the log signature output (Witt's formula).
+
+#### `basis(s)`
+
+Get the Lyndon bracket labels for the log signature basis elements.
+
+### Transforms
+
+#### `sigjoin(sig, segment, d, m, fixedLast=nan)`
+
+Extend a signature by appending a linear segment. Equivalent to `sigcombine(sig, sig_of_segment(segment), d, m)`.
+
+#### `sigjoinbackprop(deriv, sig, segment, d, m, fixedLast=nan)`
+
+Gradient through `sigjoin`. Returns `(dsig, dsegment)` or `(dsig, dsegment, dfixedLast)`.
+
+#### `sigscale(sig, scales, d, m)`
+
+Rescale a signature as if each path dimension were multiplied by a factor. At level k, the multi-index `(i1,...,ik)` component is multiplied by `scales[i1] * ... * scales[ik]`.
+
+#### `sigscalebackprop(deriv, sig, scales, d, m)`
+
+Gradient through `sigscale`. Returns `(dsig, dscales)`.
+
+### Rotation Invariants (2D paths)
+
+#### `rotinv2dprepare(m, type="a")`
+
+Precompute rotation-invariant features for 2D paths.
+
+- **m**: depth (should be even).
+- **type**: `"a"` for all invariants.
+
+#### `rotinv2d(path, s)`
+
+Compute rotation-invariant features of a 2D path signature.
+
+#### `rotinv2dlength(s)` / `rotinv2dcoeffs(s)`
+
+Get the number of invariants and their coefficient matrices.
+
+### Utility
+
+#### `version()`
+
+Return the sig-light version string.
+
+## Algorithm
+
+sig-light uses the standard approach for computing signatures of piecewise-linear paths:
+
+1. **Segment signature**: for each linear segment with displacement `h`, the signature is the truncated exponential `exp(h) = 1 + h + h^2/2! + h^3/3! + ...` in the tensor algebra.
+
+2. **Chen's identity**: the signature of a concatenated path equals the tensor product of the individual segment signatures: `S(path) = S(seg_1) * S(seg_2) * ... * S(seg_n)`.
+
+3. **Log signature**: computed by taking the tensor logarithm `log(S) = (S-1) - (S-1)^2/2 + (S-1)^3/3 - ...` and projecting onto the Lyndon word basis.
+
+4. **Backpropagation**: reverse-mode differentiation through the Chen's identity chain using adjoint operations on the tensor algebra.
+
+This approach is exact for piecewise-linear paths (no numerical approximation from ODE solvers).
+
+## Comparison with iisignature
+
+| Feature | sig-light | iisignature |
+|---|---|---|
+| Language | Pure Python + numpy | C++ with Python bindings |
+| Installation | `pip install` (no compilation) | Requires C++ compiler |
+| Performance | Slower (~7-25x for sig) | Faster |
+| API | Full parity | Full |
+| Backpropagation | Yes | Yes |
+| Batching | Yes | Yes |
+| Rotation invariants | Yes (type "a") | Yes (types a/s/q/k) |
+
+sig-light implements the full iisignature API with an identical interface. It trades performance for portability and simplicity.
+
+## Development
+
+Requires [just](https://github.com/casey/just) for task running.
+
+```bash
+# Clone and install
+git clone https://github.com/yousif-toama/sig-light.git
+cd sig-light
+just sync
+
+# Run tests
+just test
+
+# Code quality (lint + format check + type check)
+just check
+
+# Run tests with coverage
+just test-cov
+
+# Run benchmark
+just bench
+
+# Install iisignature for cross-validation testing (requires C++ compiler)
+uv pip install setuptools
+uv pip install iisignature --no-build-isolation
+uv run pytest tests/test_api_compat.py
+```
+
+## License
+
+MIT