sktime-cython 0.1.0__tar.gz

sktime_cython-0.1.0/LICENSE

@@ -0,0 +1,30 @@
+BSD 3-Clause License
+
+Copyright (c) 2019 - present, The sktime developers.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

sktime_cython-0.1.0/MANIFEST.in

@@ -0,0 +1,7 @@
+# Cython sources must ship in the sdist so it can build on the user's machine.
+recursive-include sktime_cython *.pyx *.pxd *.pyi
+include LICENSE README.md pyproject.toml setup.py
+
+# Never ship build artifacts: the .c is regenerated from .pyx at build time.
+recursive-exclude sktime_cython *.c *.so *.pyd
+global-exclude __pycache__ *.py[cod]

sktime_cython-0.1.0/PKG-INFO

@@ -0,0 +1,185 @@
+Metadata-Version: 2.4
+Name: sktime-cython
+Version: 0.1.0
+Summary: Cython extensions for sktime
+Author-email: sktime developers <sktime.toolbox@gmail.com>
+Maintainer-email: sktime developers <sktime.toolbox@gmail.com>
+License: BSD 3-Clause License
+        
+        Copyright (c) 2019 - present, The sktime developers.
+        
+        All rights reserved.
+        
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are met:
+        
+        * Redistributions of source code must retain the above copyright notice, this
+          list of conditions and the following disclaimer.
+        
+        * Redistributions in binary form must reproduce the above copyright notice,
+          this list of conditions and the following disclaimer in the documentation
+          and/or other materials provided with the distribution.
+        
+        * Neither the name of the copyright holder nor the names of its
+          contributors may be used to endorse or promote products derived from
+          this software without specific prior written permission.
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+        
+Project-URL: Homepage, https://github.com/sktime/sktime-cython
+Project-URL: Repository, https://github.com/sktime/sktime-cython
+Keywords: cython,machine-learning,scikit-learn,time-series,time-series-analysis
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Programming Language :: Cython
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development
+Requires-Python: <3.15,>=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy<2.5,>=1.21
+Provides-Extra: dev
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-timeout; extra == "dev"
+Requires-Dist: pytest-xdist; extra == "dev"
+Requires-Dist: sktime; extra == "dev"
+Requires-Dist: numba; extra == "dev"
+Dynamic: license-file
+
+# sktime-cython
+
+Cython-compiled estimators for [sktime](https://github.com/sktime/sktime).
+
+This package hosts ahead-of-time compiled implementations of sktime algorithms,
+isolating the C-compilation and binary-wheel complexity from the main `sktime`
+package. Estimators here expose a plain numpy-in/numpy-out compute layer with
+**no sktime runtime dependency**; `sktime` keeps thin `BaseTransformer` /
+`BaseEstimator` wrappers that delegate to this package.
+
+Why a separate package: compiled extensions need a C toolchain, per-platform
+wheels, and `cibuildwheel` release machinery. Keeping that here lets `sktime`
+stay pure-Python while still offering compiled, numba-free fast paths.
+
+## Estimators
+
+| Estimator | Compute API | Notes |
+|-----------|-------------|-------|
+| Multivariate MiniRocket | `sktime_cython.fit` / `transform` | numba-free; equivalent to `MiniRocketMultivariate`, no JIT warmup |
+
+More estimators are added as `.pyx` kernels under `sktime_cython/_cython/` with
+a numpy compute layer alongside.
+
+Each estimator lives in its own submodule (nothing is re-exported at the top
+level, so estimators never collide on common names like `fit`/`transform`):
+
+```python
+import numpy as np
+from sktime_cython.minirocket import fit, transform
+
+X = np.random.rand(100, 6, 500).astype("float32")
+params = fit(X, num_kernels=10_000, random_state=42)
+features = transform(X, params, n_jobs=-1)   # GIL-released kernel, real threads
+```
+
+Runtime dependency: numpy only.
+
+## Development
+
+Requires a C compiler and Python 3.10+. Run from the project root.
+
+```bash
+# editable install with the dev extra (pulls sktime + numba for equivalence
+# tests, plus pre-commit); compiles the Cython extensions via build isolation
+uv pip install -e ".[dev]"        # or: pip install -e ".[dev]"
+
+# install the git pre-commit hooks ONCE — this is what stops CI lint failures
+pre-commit install
+
+# run the tests
+python -m pytest sktime_cython -v
+```
+
+After editing a `.pyx`, recompile with `pip install -e .` again (or `make build`).
+
+`make` shortcuts (auto-detect `uv`, falling back to `pip`/`python`):
+`make install`, `make build`, `make test`, `make clean`.
+
+## Before you push (avoid CI failures)
+
+CI runs the pre-commit hooks and **fails if they reformat anything**. Running
+`pre-commit install` (above) auto-runs them on every `git commit`. To check the
+whole tree on demand:
+
+```bash
+pre-commit run --all-files
+```
+
+This runs `ruff check` (lint) and `ruff format`. If `ruff format` reports "files
+were modified", it already fixed them — `git add` the changes and commit again.
+
+## CI workflows
+
+- **`test.yml`** (push / PR to `main`): a `code-quality` job running the
+  pre-commit hooks, plus a matrix that builds the Cython extensions and runs
+  pytest across Python 3.10–3.14 on Linux, macOS, and Windows.
+- **`release.yml`** (on GitHub release): builds binary wheels with
+  [`cibuildwheel`](https://cibuildwheel.pypa.io/) for all platforms, builds an
+  sdist (with `.pyx` sources), and publishes to PyPI via trusted publishing.
+
+## Adding an estimator
+
+1. Drop the kernel `.pyx` (and optional `.pyi` stub) in a subfolder of the package.
+  The package structure mirrors that of `sktime`, files should be added paralleling
+  its primary import location in `sktime`
+2. Register the kernel as an `Extension` in `setup.py`.
+3. Add a numpy compute-layer module `sktime_cython/<name>.py` exposing the
+   estimator's public functions. Keep them in the submodule — do not re-export
+   at the top level (avoids name collisions across estimators).
+4. Add tests in a subfolder `tests`, in the same folder as the kernel.
+
+## Package structure
+
+Cython kernels and python layers should be added in a parallel location as in the
+`sktime` package.
+
+Example for minirocket:
+
+```
+sktime_cython/
+  transformations/
+    rocket/
+      __init__.py                           # public compute-layer exports
+      _minirocket.py                        # numpy fit/transform layer
+      _minirocket_multivariate_cython.pyx   # compiled kernels
+      _minirocket_multivariate_cython.pyi   # type stubs
+      tests/
+        __init__.py
+        test_minirocket.py                  # tests
+```
+
+## License
+
+BSD 3-Clause License — see [LICENSE](LICENSE).

sktime_cython-0.1.0/README.md

@@ -0,0 +1,114 @@
+# sktime-cython
+
+Cython-compiled estimators for [sktime](https://github.com/sktime/sktime).
+
+This package hosts ahead-of-time compiled implementations of sktime algorithms,
+isolating the C-compilation and binary-wheel complexity from the main `sktime`
+package. Estimators here expose a plain numpy-in/numpy-out compute layer with
+**no sktime runtime dependency**; `sktime` keeps thin `BaseTransformer` /
+`BaseEstimator` wrappers that delegate to this package.
+
+Why a separate package: compiled extensions need a C toolchain, per-platform
+wheels, and `cibuildwheel` release machinery. Keeping that here lets `sktime`
+stay pure-Python while still offering compiled, numba-free fast paths.
+
+## Estimators
+
+| Estimator | Compute API | Notes |
+|-----------|-------------|-------|
+| Multivariate MiniRocket | `sktime_cython.fit` / `transform` | numba-free; equivalent to `MiniRocketMultivariate`, no JIT warmup |
+
+More estimators are added as `.pyx` kernels under `sktime_cython/_cython/` with
+a numpy compute layer alongside.
+
+Each estimator lives in its own submodule (nothing is re-exported at the top
+level, so estimators never collide on common names like `fit`/`transform`):
+
+```python
+import numpy as np
+from sktime_cython.minirocket import fit, transform
+
+X = np.random.rand(100, 6, 500).astype("float32")
+params = fit(X, num_kernels=10_000, random_state=42)
+features = transform(X, params, n_jobs=-1)   # GIL-released kernel, real threads
+```
+
+Runtime dependency: numpy only.
+
+## Development
+
+Requires a C compiler and Python 3.10+. Run from the project root.
+
+```bash
+# editable install with the dev extra (pulls sktime + numba for equivalence
+# tests, plus pre-commit); compiles the Cython extensions via build isolation
+uv pip install -e ".[dev]"        # or: pip install -e ".[dev]"
+
+# install the git pre-commit hooks ONCE — this is what stops CI lint failures
+pre-commit install
+
+# run the tests
+python -m pytest sktime_cython -v
+```
+
+After editing a `.pyx`, recompile with `pip install -e .` again (or `make build`).
+
+`make` shortcuts (auto-detect `uv`, falling back to `pip`/`python`):
+`make install`, `make build`, `make test`, `make clean`.
+
+## Before you push (avoid CI failures)
+
+CI runs the pre-commit hooks and **fails if they reformat anything**. Running
+`pre-commit install` (above) auto-runs them on every `git commit`. To check the
+whole tree on demand:
+
+```bash
+pre-commit run --all-files
+```
+
+This runs `ruff check` (lint) and `ruff format`. If `ruff format` reports "files
+were modified", it already fixed them — `git add` the changes and commit again.
+
+## CI workflows
+
+- **`test.yml`** (push / PR to `main`): a `code-quality` job running the
+  pre-commit hooks, plus a matrix that builds the Cython extensions and runs
+  pytest across Python 3.10–3.14 on Linux, macOS, and Windows.
+- **`release.yml`** (on GitHub release): builds binary wheels with
+  [`cibuildwheel`](https://cibuildwheel.pypa.io/) for all platforms, builds an
+  sdist (with `.pyx` sources), and publishes to PyPI via trusted publishing.
+
+## Adding an estimator
+
+1. Drop the kernel `.pyx` (and optional `.pyi` stub) in a subfolder of the package.
+  The package structure mirrors that of `sktime`, files should be added paralleling
+  its primary import location in `sktime`
+2. Register the kernel as an `Extension` in `setup.py`.
+3. Add a numpy compute-layer module `sktime_cython/<name>.py` exposing the
+   estimator's public functions. Keep them in the submodule — do not re-export
+   at the top level (avoids name collisions across estimators).
+4. Add tests in a subfolder `tests`, in the same folder as the kernel.
+
+## Package structure
+
+Cython kernels and python layers should be added in a parallel location as in the
+`sktime` package.
+
+Example for minirocket:
+
+```
+sktime_cython/
+  transformations/
+    rocket/
+      __init__.py                           # public compute-layer exports
+      _minirocket.py                        # numpy fit/transform layer
+      _minirocket_multivariate_cython.pyx   # compiled kernels
+      _minirocket_multivariate_cython.pyi   # type stubs
+      tests/
+        __init__.py
+        test_minirocket.py                  # tests
+```
+
+## License
+
+BSD 3-Clause License — see [LICENSE](LICENSE).

sktime_cython-0.1.0/pyproject.toml

@@ -0,0 +1,120 @@
+[project]
+name = "sktime-cython"
+version = "0.1.0"
+description = "Cython extensions for sktime"
+readme = "README.md"
+keywords = [
+  "cython",
+  "machine-learning",
+  "scikit-learn",
+  "time-series",
+  "time-series-analysis",
+]
+license = { file = "LICENSE" }
+maintainers = [
+  { name = "sktime developers", email = "sktime.toolbox@gmail.com" },
+]
+authors = [
+  { name = "sktime developers", email = "sktime.toolbox@gmail.com" },
+]
+requires-python = ">=3.10,<3.15"
+classifiers = [
+  "Intended Audience :: Developers",
+  "Intended Audience :: Science/Research",
+  "License :: OSI Approved :: BSD License",
+  "Operating System :: MacOS",
+  "Operating System :: Microsoft :: Windows",
+  "Operating System :: POSIX",
+  "Operating System :: Unix",
+  "Programming Language :: Cython",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Topic :: Scientific/Engineering",
+  "Topic :: Scientific/Engineering :: Artificial Intelligence",
+  "Topic :: Software Development",
+]
+dependencies = [
+  "numpy>=1.21,<2.5",
+]
+
+[project.optional-dependencies]
+dev = [
+  "pre-commit",
+  "pytest",
+  "pytest-timeout",
+  "pytest-xdist",
+  # sktime + numba power the equivalence test (Cython vs numba MiniRocket).
+  # Dev-only: runtime deps stay numpy-only.
+  "sktime",
+  "numba",
+]
+
+[project.urls]
+Homepage = "https://github.com/sktime/sktime-cython"
+Repository = "https://github.com/sktime/sktime-cython"
+
+[build-system]
+requires = [
+  "Cython>=3.0",
+  "numpy>=1.21",
+  "setuptools>=70.1",
+]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+exclude = ["tests", "tests.*"]
+
+[tool.cibuildwheel]
+# CPython only; PyPy has no upstream numpy wheels for this matrix, so skip it.
+# requires-python in [project] already bounds the CPython versions built.
+skip = ["pp*"]
+# Run tests after each wheel build to verify the Cython extensions actually
+# work. --pyargs imports the installed wheel by name instead of collecting from
+# the source tree, so this exercises the built artifact.
+test-requires = ["pytest"]
+test-command = "python -m pytest --pyargs sktime_cython -v"
+
+[tool.ruff]
+line-length = 88
+target-version = "py310"
+
+[tool.ruff.lint]
+select = [
+  "D",
+  "E",
+  "W",
+  "F",
+  "S",
+  "UP",
+  "I",
+  "C4",
+]
+ignore = [
+  "E203",
+  "E402",
+  "E731",
+  "S101",
+  "RUF100",
+  "E741",
+]
+
+[tool.ruff.lint.pydocstyle]
+convention = "numpy"
+
+[tool.ruff.lint.per-file-ignores]
+"**/__init__.py" = [
+  "F401",
+]
+"**/tests/**" = [
+  "D",
+  "S605",
+  "S607",
+  "PT004",
+  "PT011",
+  "PT012",
+]

sktime_cython-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sktime_cython-0.1.0/setup.py

@@ -0,0 +1,32 @@
+"""Setup script for sktime-cython Cython extensions."""
+
+import sys
+
+import numpy as np
+from Cython.Build import cythonize
+from setuptools import Extension, setup
+
+# fast-math is the bulk of the speedup vs numba; flags are platform-specific.
+if sys.platform == "win32":
+    _fast = ["/O2", "/fp:fast"]
+else:
+    _fast = ["-O3", "-ffast-math"]
+
+extensions = [
+    Extension(
+        "sktime_cython.transformations.rocket._minirocket_multivariate_cython",
+        sources=[
+            "sktime_cython/transformations/rocket/_minirocket_multivariate_cython.pyx"
+        ],
+        include_dirs=[np.get_include()],
+        define_macros=[("NPY_NO_DEPRECATED_API", "NPY_1_7_API_VERSION")],
+        extra_compile_args=_fast,
+    ),
+]
+
+setup(
+    ext_modules=cythonize(
+        extensions,
+        compiler_directives={"language_level": "3"},
+    ),
+)

sktime_cython-0.1.0/sktime_cython/__init__.py

@@ -0,0 +1,6 @@
+"""sktime-cython - Cython extensions for sktime.
+
+Each estimator lives in its own submodule and exposes its own compute API,
+e.g. ``from sktime_cython.minirocket import fit, transform``. Nothing is
+re-exported at the top level, so estimators never collide on common names.
+"""

sktime_cython-0.1.0/sktime_cython/transformations/__init__.py

@@ -0,0 +1 @@
+"""Transformations."""

sktime_cython-0.1.0/sktime_cython/transformations/rocket/__init__.py

@@ -0,0 +1,8 @@
+"""Rocket transformers."""
+
+from sktime_cython.transformations.rocket._minirocket import (
+    rocket_fit,
+    rocket_transform,
+)
+
+__all__ = ["rocket_fit", "rocket_transform"]

sktime_cython-0.1.0/sktime_cython/transformations/rocket/_minirocket.py

@@ -0,0 +1,201 @@
+"""Numba-free MiniRocket multivariate transform (pure-numpy + Cython core).
+
+Compute layer with no sktime dependency: numpy arrays in, numpy arrays out.
+``fit`` returns a parameter tuple; ``transform`` applies it. An sktime
+``BaseTransformer`` wrapper delegates to these two functions.
+"""
+
+import multiprocessing
+from concurrent.futures import ThreadPoolExecutor
+
+import numpy as np
+
+from sktime_cython.transformations.rocket import _minirocket_multivariate_cython as _cy
+
+__all__ = ["rocket_fit", "rocket_transform"]
+
+_NUM_KERNELS = 84
+
+
+def _fit_dilations(n_timepoints, num_features, max_dilations_per_kernel):
+    """Dilation schedule (pure numpy, copied from sktime numba module)."""
+    num_kernels = _NUM_KERNELS
+    if num_features < num_kernels:
+        num_features = num_kernels
+
+    num_features_per_kernel = num_features // num_kernels
+    true_max_dilations_per_kernel = min(
+        num_features_per_kernel, max_dilations_per_kernel
+    )
+    multiplier = num_features_per_kernel / true_max_dilations_per_kernel
+
+    max_exponent = np.log2((n_timepoints - 1) / (9 - 1))
+    dilations, num_features_per_dilation = np.unique(
+        np.logspace(0, max_exponent, true_max_dilations_per_kernel, base=2).astype(
+            np.int32
+        ),
+        return_counts=True,
+    )
+    num_features_per_dilation = (num_features_per_dilation * multiplier).astype(
+        np.int32
+    )
+
+    remainder = num_features_per_kernel - np.sum(num_features_per_dilation)
+    i = 0
+    while remainder > 0:
+        num_features_per_dilation[i] += 1
+        remainder -= 1
+        i = (i + 1) % len(num_features_per_dilation)
+
+    return dilations, num_features_per_dilation
+
+
+def _quantiles(n):
+    """Evenly-spaced low-discrepancy quantile points (copied from sktime)."""
+    return np.array(
+        [(_ * ((np.sqrt(5) + 1) / 2)) % 1 for _ in range(1, n + 1)], dtype=np.float32
+    )
+
+
+def rocket_fit(X, num_kernels=10_000, max_dilations_per_kernel=32, random_state=None):
+    """Fit dilations, channel selections, and biases.
+
+    Parameters
+    ----------
+    X : 3D np.ndarray, shape (n_instances, n_columns, n_timepoints)
+        panel of time series; cast to float32 internally.
+    num_kernels : int, default=10000
+        number of kernels; rounded down to a multiple of 84 (min 84).
+    max_dilations_per_kernel : int, default=32
+        maximum number of dilations per kernel.
+    random_state : int or None, default=None
+        seed for reproducibility.
+
+    Returns
+    -------
+    parameters : tuple of np.ndarray
+        (num_channels_per_combination, channel_indices, dilations,
+        num_features_per_dilation, biases), ready to pass to ``transform``.
+    """
+    if random_state is not None and not isinstance(random_state, (int, np.integer)):
+        raise ValueError(
+            f"random_state must be int or None, but found {type(random_state)}"
+        )
+    seed = np.int32(random_state) if random_state is not None else None
+
+    X = np.ascontiguousarray(X, dtype=np.float32)
+    n_instances, n_columns, n_timepoints = X.shape
+    if n_timepoints < 9:
+        raise ValueError(
+            f"n_timepoints must be >= 9, but found {n_timepoints};"
+            " zero pad shorter series so that n_timepoints == 9"
+        )
+
+    if seed is not None:
+        np.random.seed(seed)
+
+    num_kernels_ = _NUM_KERNELS
+    dilations, num_features_per_dilation = _fit_dilations(
+        n_timepoints, num_kernels, max_dilations_per_kernel
+    )
+    num_features_per_kernel = np.sum(num_features_per_dilation)
+    quantiles = _quantiles(num_kernels_ * num_features_per_kernel)
+
+    num_dilations = len(dilations)
+    num_combinations = num_kernels_ * num_dilations
+
+    max_num_channels = min(n_columns, 9)
+    max_exponent = np.log2(max_num_channels + 1)
+
+    num_channels_per_combination = (
+        2 ** np.random.uniform(0, max_exponent, num_combinations)
+    ).astype(np.int32)
+
+    channel_indices = np.zeros(num_channels_per_combination.sum(), dtype=np.int32)
+    num_channels_start = 0
+    for combination_index in range(num_combinations):
+        n_this = num_channels_per_combination[combination_index]
+        num_channels_end = num_channels_start + n_this
+        channel_indices[num_channels_start:num_channels_end] = np.random.choice(
+            n_columns, n_this, replace=False
+        )
+        num_channels_start = num_channels_end
+
+    # biases: re-seed (matching numba _fit_biases_multi), draw one instance
+    # index per combination, build C in Cython, then quantile per combination.
+    if seed is not None:
+        np.random.seed(seed)
+    instance_indices = np.array(
+        [np.random.randint(n_instances) for _ in range(num_combinations)],
+        dtype=np.int32,
+    )
+    C = _cy.fit_biases(
+        X,
+        num_channels_per_combination,
+        channel_indices,
+        dilations.astype(np.int32),
+        num_features_per_dilation.astype(np.int32),
+        instance_indices,
+    )
+
+    biases = np.zeros(num_kernels_ * int(num_features_per_kernel), dtype=np.float32)
+    feature_index_start = 0
+    combination_index = 0
+    for dilation_index in range(num_dilations):
+        nfd = num_features_per_dilation[dilation_index]
+        for _kernel_index in range(num_kernels_):
+            feature_index_end = feature_index_start + nfd
+            biases[feature_index_start:feature_index_end] = np.quantile(
+                C[combination_index],
+                quantiles[feature_index_start:feature_index_end],
+            ).astype(np.float32)
+            feature_index_start = feature_index_end
+            combination_index += 1
+
+    return (
+        num_channels_per_combination,
+        channel_indices,
+        dilations.astype(np.int32),
+        num_features_per_dilation.astype(np.int32),
+        biases,
+    )
+
+
+def rocket_transform(X, parameters, n_jobs=1):
+    """Apply a fitted MiniRocket transform.
+
+    Parameters
+    ----------
+    X : 3D np.ndarray, shape (n_instances, n_columns, n_timepoints)
+        panel of time series; cast to contiguous float32 internally.
+    parameters : tuple
+        the tuple returned by ``fit``.
+    n_jobs : int, default=1
+        threads for the GIL-releasing Cython kernel over disjoint instance
+        chunks. ``-1`` (or out of range) uses all processors.
+
+    Returns
+    -------
+    np.ndarray, shape (n_instances, n_features), float32
+    """
+    X = np.ascontiguousarray(X, dtype=np.float32)
+    n_instances = X.shape[0]
+
+    if n_jobs < 1 or n_jobs > multiprocessing.cpu_count():
+        n_jobs = multiprocessing.cpu_count()
+    n_jobs = min(n_jobs, n_instances)
+
+    if n_jobs <= 1:
+        return _cy.transform(X, *parameters)
+
+    # the Cython kernel releases the GIL, so plain threads run truly in
+    # parallel across disjoint instance chunks.
+    bounds = np.linspace(0, n_instances, n_jobs + 1).astype(int)
+    chunks = [
+        np.ascontiguousarray(X[bounds[i] : bounds[i + 1]])
+        for i in range(n_jobs)
+        if bounds[i + 1] > bounds[i]
+    ]
+    with ThreadPoolExecutor(max_workers=n_jobs) as ex:
+        parts = list(ex.map(lambda c: _cy.transform(c, *parameters), chunks))
+    return np.vstack(parts)

sktime_cython-0.1.0/sktime_cython/transformations/rocket/_minirocket_multivariate_cython.pyi

@@ -0,0 +1,21 @@
+"""Type stubs for the compiled MiniRocketMultivariate Cython kernels."""
+
+import numpy as np
+from numpy.typing import NDArray
+
+def transform(
+    X: NDArray[np.float32],
+    num_channels_per_combination: NDArray[np.int32],
+    channel_indices: NDArray[np.int32],
+    dilations: NDArray[np.int32],
+    num_features_per_dilation: NDArray[np.int32],
+    biases: NDArray[np.float32],
+) -> NDArray[np.float32]: ...
+def fit_biases(
+    X: NDArray[np.float32],
+    num_channels_per_combination: NDArray[np.int32],
+    channel_indices: NDArray[np.int32],
+    dilations: NDArray[np.int32],
+    num_features_per_dilation: NDArray[np.int32],
+    instance_indices: NDArray[np.int32],
+) -> NDArray[np.float32]: ...

sktime_cython-0.1.0/sktime_cython/transformations/rocket/_minirocket_multivariate_cython.pyx

@@ -0,0 +1,289 @@
+# cython: language_level=3, boundscheck=False, wraparound=False, cdivision=True
+"""Cython MiniRocketMultivariate kernels.
+
+Ahead-of-time compiled ports of sktime's ``_minirocket_multi_numba`` kernels
+(``_fit_biases_multi`` and ``_transform_multi``). Same math, no numba JIT
+warmup. Both consume float32/int32 arrays produced by the pure-numpy fit
+scaffolding in ``MiniRocketMultivariateCython`` and are numerically equivalent
+to the numba implementation (verified against it as groundtruth in tests).
+"""
+
+import numpy as np
+
+cimport numpy as cnp
+from libc.stdlib cimport free, malloc
+
+cnp.import_array()
+
+# combinations(range(9), 3) -> 84 kernels, flattened to 252 int32.
+cdef int[252] _IDX
+cdef int _fill_idx():
+    cdef int n = 0, i, j, k
+    for i in range(9):
+        for j in range(i + 1, 9):
+            for k in range(j + 1, 9):
+                _IDX[3 * n] = i
+                _IDX[3 * n + 1] = j
+                _IDX[3 * n + 2] = k
+                n += 1
+    return n
+cdef int _NUM_KERNELS = _fill_idx()
+
+
+def transform(
+    cnp.ndarray[cnp.float32_t, ndim=3, mode="c"] X,
+    int[::1] num_channels_per_combination,
+    int[::1] channel_indices,
+    int[::1] dilations,
+    int[::1] num_features_per_dilation,
+    float[::1] biases,
+):
+    """Port of ``_transform_multi``. X is (n_instances, n_columns, n_timepoints)."""
+    cdef int n_instances = X.shape[0]
+    cdef int n_columns = X.shape[1]
+    cdef int n_timepoints = X.shape[2]
+    cdef float[:, :, ::1] Xv = X
+
+    cdef int num_kernels = _NUM_KERNELS
+    cdef int num_dilations = dilations.shape[0]
+
+    cdef int total_fpd = 0
+    cdef int d
+    for d in range(num_dilations):
+        total_fpd += num_features_per_dilation[d]
+    cdef int num_features = num_kernels * total_fpd
+
+    cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] features = np.zeros(
+        (n_instances, num_features), dtype=np.float32
+    )
+    cdef float[:, ::1] feat = features
+
+    cdef int csize = n_columns * n_timepoints
+    # Per-instance work buffers (single-threaded; reused across dilations).
+    cdef float* C_alpha = <float*>malloc(csize * sizeof(float))
+    cdef float* C_gamma = <float*>malloc(9 * csize * sizeof(float))
+    cdef float* C = <float*>malloc(n_timepoints * sizeof(float))
+    if C_alpha == NULL or C_gamma == NULL or C == NULL:
+        free(C_alpha); free(C_gamma); free(C)
+        raise MemoryError()
+
+    cdef int ex, di, ki, g, c, t, ch
+    cdef int padding, padding0, padding1, nfd, dilation
+    cdef int start, end, base, combination_index
+    cdef int fis, fie, ncc, ncs, nce
+    cdef int i0, i1, i2, fc, n_valid, lo, hi
+    cdef float bias, x, count
+
+    try:
+      with nogil:
+        for ex in range(n_instances):
+            fis = 0
+            ncs = 0
+            combination_index = 0
+            for di in range(num_dilations):
+                padding0 = di % 2
+                dilation = dilations[di]
+                padding = ((9 - 1) * dilation) // 2
+                nfd = num_features_per_dilation[di]
+
+                # C_alpha = A = -X ; C_gamma = 0 ; C_gamma[4] = G = 3X
+                for c in range(n_columns):
+                    base = c * n_timepoints
+                    for t in range(n_timepoints):
+                        x = Xv[ex, c, t]
+                        C_alpha[base + t] = -x
+                        C_gamma[4 * csize + base + t] = x + x + x
+                for g in range(9):
+                    if g == 4:
+                        continue
+                    for c in range(n_columns):
+                        base = g * csize + c * n_timepoints
+                        for t in range(n_timepoints):
+                            C_gamma[base + t] = 0.0
+
+                # gamma_index 0..3
+                end = n_timepoints - padding
+                for g in range(4):
+                    if end > 0:
+                        for c in range(n_columns):
+                            base = c * n_timepoints
+                            for t in range(end):
+                                C_alpha[base + n_timepoints - end + t] += -Xv[ex, c, t]
+                                C_gamma[g * csize + base + n_timepoints - end + t] = (
+                                    3.0 * Xv[ex, c, t]
+                                )
+                    end += dilation
+
+                # gamma_index 5..8
+                start = dilation
+                for g in range(5, 9):
+                    if start < n_timepoints:
+                        for c in range(n_columns):
+                            base = c * n_timepoints
+                            for t in range(n_timepoints - start):
+                                C_alpha[base + t] += -Xv[ex, c, start + t]
+                                C_gamma[g * csize + base + t] = (
+                                    3.0 * Xv[ex, c, start + t]
+                                )
+                    start += dilation
+
+                for ki in range(num_kernels):
+                    fie = fis + nfd
+                    ncc = num_channels_per_combination[combination_index]
+                    nce = ncs + ncc
+                    padding1 = (padding0 + ki) % 2
+                    i0 = _IDX[3 * ki]
+                    i1 = _IDX[3 * ki + 1]
+                    i2 = _IDX[3 * ki + 2]
+
+                    # C[t] = sum over the combination's channels
+                    for t in range(n_timepoints):
+                        C[t] = 0.0
+                    for ch in range(ncs, nce):
+                        c = channel_indices[ch]
+                        base = c * n_timepoints
+                        for t in range(n_timepoints):
+                            C[t] += (
+                                C_alpha[base + t]
+                                + C_gamma[i0 * csize + base + t]
+                                + C_gamma[i1 * csize + base + t]
+                                + C_gamma[i2 * csize + base + t]
+                            )
+
+                    if padding1 == 0:
+                        lo = 0
+                        hi = n_timepoints
+                    else:
+                        lo = padding
+                        hi = n_timepoints - padding
+                    n_valid = hi - lo
+
+                    if n_valid > 0:
+                        for fc in range(nfd):
+                            bias = biases[fis + fc]
+                            count = 0.0
+                            for t in range(lo, hi):
+                                if C[t] > bias:
+                                    count += 1.0
+                            feat[ex, fis + fc] = count / n_valid
+
+                    fis = fie
+                    combination_index += 1
+                    ncs = nce
+    finally:
+        free(C_alpha)
+        free(C_gamma)
+        free(C)
+
+    return features
+
+
+def fit_biases(
+    cnp.ndarray[cnp.float32_t, ndim=3, mode="c"] X,
+    int[::1] num_channels_per_combination,
+    int[::1] channel_indices,
+    int[::1] dilations,
+    int[::1] num_features_per_dilation,
+    int[::1] instance_indices,
+):
+    """Build per-combination convolution output C, summed over channels.
+
+    Port of the convolution-building half of ``_fit_biases_multi``. Returns a
+    ``(num_combinations, n_timepoints)`` float32 array; the caller applies
+    ``np.quantile`` per combination to obtain biases. ``instance_indices`` holds
+    the ``np.random.randint(n_instances)`` draw for each combination, computed by
+    the caller to reproduce the numba random sequence exactly.
+    """
+    cdef int n_timepoints = X.shape[2]
+    cdef float[:, :, ::1] Xv = X
+
+    cdef int num_kernels = _NUM_KERNELS
+    cdef int num_dilations = dilations.shape[0]
+    cdef int num_combinations = num_kernels * num_dilations
+
+    cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] out = np.zeros(
+        (num_combinations, n_timepoints), dtype=np.float32
+    )
+    cdef float[:, ::1] outv = out
+
+    # 9 gamma planes x n_timepoints for a single (instance, channel) row.
+    cdef float* C_alpha = <float*>malloc(n_timepoints * sizeof(float))
+    cdef float* C_gamma = <float*>malloc(9 * n_timepoints * sizeof(float))
+    if C_alpha == NULL or C_gamma == NULL:
+        free(C_alpha); free(C_gamma)
+        raise MemoryError()
+
+    cdef int di, ki, g, t, ch, ex, c
+    cdef int padding, dilation, start, end
+    cdef int comb, ncs, nce, ncc
+    cdef int i0, i1, i2
+    cdef float x
+
+    try:
+        comb = 0
+        ncs = 0
+        for di in range(num_dilations):
+            dilation = dilations[di]
+            padding = ((9 - 1) * dilation) // 2
+
+            for ki in range(num_kernels):
+                ncc = num_channels_per_combination[comb]
+                nce = ncs + ncc
+                ex = instance_indices[comb]
+                i0 = _IDX[3 * ki]
+                i1 = _IDX[3 * ki + 1]
+                i2 = _IDX[3 * ki + 2]
+
+                for t in range(n_timepoints):
+                    outv[comb, t] = 0.0
+
+                # Accumulate C = C_alpha + C_gamma[i0,i1,i2], summed over channels.
+                for ch in range(ncs, nce):
+                    c = channel_indices[ch]
+
+                    # C_alpha = A = -X ; C_gamma = 0 ; C_gamma[4] = G = 3X
+                    for t in range(n_timepoints):
+                        x = Xv[ex, c, t]
+                        C_alpha[t] = -x
+                        C_gamma[4 * n_timepoints + t] = x + x + x
+                    for g in range(9):
+                        if g == 4:
+                            continue
+                        for t in range(n_timepoints):
+                            C_gamma[g * n_timepoints + t] = 0.0
+
+                    end = n_timepoints - padding
+                    for g in range(4):
+                        if end > 0:
+                            for t in range(end):
+                                C_alpha[n_timepoints - end + t] += -Xv[ex, c, t]
+                                C_gamma[g * n_timepoints + n_timepoints - end + t] = (
+                                    3.0 * Xv[ex, c, t]
+                                )
+                        end += dilation
+
+                    start = dilation
+                    for g in range(5, 9):
+                        if start < n_timepoints:
+                            for t in range(n_timepoints - start):
+                                C_alpha[t] += -Xv[ex, c, start + t]
+                                C_gamma[g * n_timepoints + t] = (
+                                    3.0 * Xv[ex, c, start + t]
+                                )
+                        start += dilation
+
+                    for t in range(n_timepoints):
+                        outv[comb, t] += (
+                            C_alpha[t]
+                            + C_gamma[i0 * n_timepoints + t]
+                            + C_gamma[i1 * n_timepoints + t]
+                            + C_gamma[i2 * n_timepoints + t]
+                        )
+
+                comb += 1
+                ncs = nce
+    finally:
+        free(C_alpha)
+        free(C_gamma)
+
+    return out

sktime_cython-0.1.0/sktime_cython/transformations/rocket/tests/__init__.py

@@ -0,0 +1 @@
+"""Rocket unit tests."""

sktime_cython-0.1.0/sktime_cython/transformations/rocket/tests/test_minirocket_cython.py

@@ -0,0 +1,83 @@
+"""Tests for the Cython MiniRocket transform.
+
+The shape / threading / guard tests are self-contained (no sktime) so they run
+in cibuildwheel's isolated wheel-test env, which installs only pytest. The
+equivalence-vs-numba test imports sktime lazily and is skipped where sktime is
+absent (install the ``dev`` extra to run it).
+"""
+
+import importlib.util
+
+import numpy as np
+import pytest
+
+from sktime_cython.transformations.rocket._minirocket import (
+    rocket_fit,
+    rocket_transform,
+)
+
+# sktime is only present with the `dev` extra; the cibuildwheel wheel-test env
+# installs pytest only. find_spec detects absence without importing.
+_HAS_SKTIME = importlib.util.find_spec("sktime") is not None
+
+
+def _panel(seed, n_columns=3, n_timepoints=60):
+    rng = np.random.RandomState(seed)
+    return rng.normal(size=(6, n_columns, n_timepoints)).astype(np.float32)
+
+
+@pytest.mark.skipif(not _HAS_SKTIME, reason="sktime not installed (dev extra)")
+@pytest.mark.parametrize("n_columns", [1, 4])
+@pytest.mark.parametrize(
+    "num_kernels,max_dilations_per_kernel,random_state",
+    [(84, 32, 42), (168, 16, 7), (84, 32, 0)],
+)
+def test_cython_matches_numba(
+    n_columns, num_kernels, max_dilations_per_kernel, random_state
+):
+    """Cython transform must match the numba implementation (groundtruth)."""
+    from sktime.transformations.rocket import MiniRocketMultivariate
+
+    X = _panel(random_state, n_columns=n_columns)
+
+    numba_out = MiniRocketMultivariate(
+        num_kernels=num_kernels,
+        max_dilations_per_kernel=max_dilations_per_kernel,
+        random_state=random_state,
+    ).fit_transform(X)
+
+    params = rocket_fit(
+        X,
+        num_kernels=num_kernels,
+        max_dilations_per_kernel=max_dilations_per_kernel,
+        random_state=random_state,
+    )
+    cython_out = rocket_transform(X, params)
+
+    assert cython_out.shape == numba_out.shape
+    np.testing.assert_allclose(cython_out, numba_out.to_numpy(), rtol=1e-4, atol=1e-5)
+
+
+@pytest.mark.parametrize("num_kernels", [84, 168])
+def test_output_shape(num_kernels):
+    """transform yields (n_instances, num_kernels) float32 features."""
+    X = _panel(0)
+    out = rocket_transform(X, rocket_fit(X, num_kernels=num_kernels, random_state=0))
+    assert out.shape == (X.shape[0], num_kernels)
+    assert out.dtype == np.float32
+
+
+def test_threaded_matches_serial():
+    """n_jobs>1 must match the single-threaded result."""
+    X = _panel(3)
+    params = rocket_fit(X, num_kernels=168, random_state=1)
+    np.testing.assert_array_equal(
+        rocket_transform(X, params, n_jobs=1), rocket_transform(X, params, n_jobs=4)
+    )
+
+
+def test_too_short_series_raises():
+    """n_timepoints < 9 is rejected."""
+    X = _panel(0, n_timepoints=8)
+    with pytest.raises(ValueError, match="n_timepoints must be >= 9"):
+        rocket_fit(X)

sktime_cython-0.1.0/sktime_cython.egg-info/PKG-INFO

@@ -0,0 +1,185 @@
+Metadata-Version: 2.4
+Name: sktime-cython
+Version: 0.1.0
+Summary: Cython extensions for sktime
+Author-email: sktime developers <sktime.toolbox@gmail.com>
+Maintainer-email: sktime developers <sktime.toolbox@gmail.com>
+License: BSD 3-Clause License
+        
+        Copyright (c) 2019 - present, The sktime developers.
+        
+        All rights reserved.
+        
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are met:
+        
+        * Redistributions of source code must retain the above copyright notice, this
+          list of conditions and the following disclaimer.
+        
+        * Redistributions in binary form must reproduce the above copyright notice,
+          this list of conditions and the following disclaimer in the documentation
+          and/or other materials provided with the distribution.
+        
+        * Neither the name of the copyright holder nor the names of its
+          contributors may be used to endorse or promote products derived from
+          this software without specific prior written permission.
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+        
+Project-URL: Homepage, https://github.com/sktime/sktime-cython
+Project-URL: Repository, https://github.com/sktime/sktime-cython
+Keywords: cython,machine-learning,scikit-learn,time-series,time-series-analysis
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Programming Language :: Cython
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development
+Requires-Python: <3.15,>=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy<2.5,>=1.21
+Provides-Extra: dev
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-timeout; extra == "dev"
+Requires-Dist: pytest-xdist; extra == "dev"
+Requires-Dist: sktime; extra == "dev"
+Requires-Dist: numba; extra == "dev"
+Dynamic: license-file
+
+# sktime-cython
+
+Cython-compiled estimators for [sktime](https://github.com/sktime/sktime).
+
+This package hosts ahead-of-time compiled implementations of sktime algorithms,
+isolating the C-compilation and binary-wheel complexity from the main `sktime`
+package. Estimators here expose a plain numpy-in/numpy-out compute layer with
+**no sktime runtime dependency**; `sktime` keeps thin `BaseTransformer` /
+`BaseEstimator` wrappers that delegate to this package.
+
+Why a separate package: compiled extensions need a C toolchain, per-platform
+wheels, and `cibuildwheel` release machinery. Keeping that here lets `sktime`
+stay pure-Python while still offering compiled, numba-free fast paths.
+
+## Estimators
+
+| Estimator | Compute API | Notes |
+|-----------|-------------|-------|
+| Multivariate MiniRocket | `sktime_cython.fit` / `transform` | numba-free; equivalent to `MiniRocketMultivariate`, no JIT warmup |
+
+More estimators are added as `.pyx` kernels under `sktime_cython/_cython/` with
+a numpy compute layer alongside.
+
+Each estimator lives in its own submodule (nothing is re-exported at the top
+level, so estimators never collide on common names like `fit`/`transform`):
+
+```python
+import numpy as np
+from sktime_cython.minirocket import fit, transform
+
+X = np.random.rand(100, 6, 500).astype("float32")
+params = fit(X, num_kernels=10_000, random_state=42)
+features = transform(X, params, n_jobs=-1)   # GIL-released kernel, real threads
+```
+
+Runtime dependency: numpy only.
+
+## Development
+
+Requires a C compiler and Python 3.10+. Run from the project root.
+
+```bash
+# editable install with the dev extra (pulls sktime + numba for equivalence
+# tests, plus pre-commit); compiles the Cython extensions via build isolation
+uv pip install -e ".[dev]"        # or: pip install -e ".[dev]"
+
+# install the git pre-commit hooks ONCE — this is what stops CI lint failures
+pre-commit install
+
+# run the tests
+python -m pytest sktime_cython -v
+```
+
+After editing a `.pyx`, recompile with `pip install -e .` again (or `make build`).
+
+`make` shortcuts (auto-detect `uv`, falling back to `pip`/`python`):
+`make install`, `make build`, `make test`, `make clean`.
+
+## Before you push (avoid CI failures)
+
+CI runs the pre-commit hooks and **fails if they reformat anything**. Running
+`pre-commit install` (above) auto-runs them on every `git commit`. To check the
+whole tree on demand:
+
+```bash
+pre-commit run --all-files
+```
+
+This runs `ruff check` (lint) and `ruff format`. If `ruff format` reports "files
+were modified", it already fixed them — `git add` the changes and commit again.
+
+## CI workflows
+
+- **`test.yml`** (push / PR to `main`): a `code-quality` job running the
+  pre-commit hooks, plus a matrix that builds the Cython extensions and runs
+  pytest across Python 3.10–3.14 on Linux, macOS, and Windows.
+- **`release.yml`** (on GitHub release): builds binary wheels with
+  [`cibuildwheel`](https://cibuildwheel.pypa.io/) for all platforms, builds an
+  sdist (with `.pyx` sources), and publishes to PyPI via trusted publishing.
+
+## Adding an estimator
+
+1. Drop the kernel `.pyx` (and optional `.pyi` stub) in a subfolder of the package.
+  The package structure mirrors that of `sktime`, files should be added paralleling
+  its primary import location in `sktime`
+2. Register the kernel as an `Extension` in `setup.py`.
+3. Add a numpy compute-layer module `sktime_cython/<name>.py` exposing the
+   estimator's public functions. Keep them in the submodule — do not re-export
+   at the top level (avoids name collisions across estimators).
+4. Add tests in a subfolder `tests`, in the same folder as the kernel.
+
+## Package structure
+
+Cython kernels and python layers should be added in a parallel location as in the
+`sktime` package.
+
+Example for minirocket:
+
+```
+sktime_cython/
+  transformations/
+    rocket/
+      __init__.py                           # public compute-layer exports
+      _minirocket.py                        # numpy fit/transform layer
+      _minirocket_multivariate_cython.pyx   # compiled kernels
+      _minirocket_multivariate_cython.pyi   # type stubs
+      tests/
+        __init__.py
+        test_minirocket.py                  # tests
+```
+
+## License
+
+BSD 3-Clause License — see [LICENSE](LICENSE).

sktime_cython-0.1.0/sktime_cython.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+setup.py
+sktime_cython/__init__.py
+sktime_cython.egg-info/PKG-INFO
+sktime_cython.egg-info/SOURCES.txt
+sktime_cython.egg-info/dependency_links.txt
+sktime_cython.egg-info/requires.txt
+sktime_cython.egg-info/top_level.txt
+sktime_cython/transformations/__init__.py
+sktime_cython/transformations/rocket/__init__.py
+sktime_cython/transformations/rocket/_minirocket.py
+sktime_cython/transformations/rocket/_minirocket_multivariate_cython.pyi
+sktime_cython/transformations/rocket/_minirocket_multivariate_cython.pyx
+sktime_cython/transformations/rocket/tests/__init__.py
+sktime_cython/transformations/rocket/tests/test_minirocket_cython.py

sktime_cython-0.1.0/sktime_cython.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sktime_cython-0.1.0/sktime_cython.egg-info/requires.txt

@@ -0,0 +1,9 @@
+numpy<2.5,>=1.21
+
+[dev]
+pre-commit
+pytest
+pytest-timeout
+pytest-xdist
+sktime
+numba

sktime_cython-0.1.0/sktime_cython.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+dist
+sktime_cython