maturin 0.12.19__py3-none-win_amd64.whl → 1.11.4__py3-none-win_amd64.whl

maturin/__init__.py

@@ -1,4 +1,3 @@
-#!/usr/bin/env python3
 """
 maturin's implementation of the PEP 517 interface. Calls maturin through subprocess
 
@@ -9,61 +8,113 @@ even though the terminal supports utf8. Writing directly to the binary stdout bu
 maturin's emojis.
 """
 
+from __future__ import annotations
+
 import os
+import platform
 import shlex
 import shutil
+import struct
 import subprocess
 import sys
 from subprocess import SubprocessError
-from typing import Dict
-
-try:
-    import tomllib
-except ModuleNotFoundError:
-    import tomli as tomllib
+from typing import Any, Dict, Mapping, List, Optional
 
 
 def get_config() -> Dict[str, str]:
+    try:
+        import tomllib
+    except ModuleNotFoundError:
+        import tomli as tomllib  # type: ignore
+
     with open("pyproject.toml", "rb") as fp:
         pyproject_toml = tomllib.load(fp)
     return pyproject_toml.get("tool", {}).get("maturin", {})
 
 
-def get_maturin_pep517_args():
-    args = shlex.split(os.getenv("MATURIN_PEP517_ARGS", ""))
+def get_maturin_pep517_args(config_settings: Optional[Mapping[str, Any]] = None) -> List[str]:
+    build_args = None
+    if config_settings:
+        # TODO: Deprecate and remove build-args in favor of maturin.build-args in maturin 2.0
+        build_args = config_settings.get("maturin.build-args", config_settings.get("build-args"))
+    if build_args is None:
+        env_args = os.getenv("MATURIN_PEP517_ARGS", "")
+        args = shlex.split(env_args)
+    elif isinstance(build_args, str):
+        args = shlex.split(build_args)
+    else:
+        args = build_args
     return args
 
 
+def _get_sys_executable() -> str:
+    executable = sys.executable
+    if os.getenv("MATURIN_PEP517_USE_BASE_PYTHON") in {"1", "true"} or get_config().get("use-base-python"):
+        # Use the base interpreter path when running inside a venv to avoid recompilation
+        # when switching between venvs
+        base_executable = getattr(sys, "_base_executable")
+        if base_executable and os.path.exists(base_executable):
+            executable = os.path.realpath(base_executable)
+    return executable
+
+
+def _additional_pep517_args() -> List[str]:
+    # Support building for 32-bit Python on x64 Windows
+    if platform.system().lower() == "windows" and platform.machine().lower() == "amd64":
+        pointer_width = struct.calcsize("P") * 8
+        if pointer_width == 32:
+            return ["--target", "i686-pc-windows-msvc"]
+    return []
+
+
+def _get_env() -> Optional[Dict[str, str]]:
+    if not os.environ.get("MATURIN_NO_INSTALL_RUST") and not shutil.which("cargo"):
+        from puccinialin import setup_rust
+
+        print("Rust not found, installing into a temporary directory")
+        extra_env = setup_rust()
+        return {**os.environ, **extra_env}
+    else:
+        return None
+
+
 # noinspection PyUnusedLocal
 def _build_wheel(
-    wheel_directory, config_settings=None, metadata_directory=None, editable=False
-):
+    wheel_directory: str,
+    config_settings: Optional[Mapping[str, Any]] = None,
+    metadata_directory: Optional[str] = None,
+    editable: bool = False,
+) -> str:
     # PEP 517 specifies that only `sys.executable` points to the correct
     # python interpreter
-    command = [
+    base_command = [
         "maturin",
         "pep517",
         "build-wheel",
         "-i",
-        sys.executable,
-        "--compatibility",
-        "off",
+        _get_sys_executable(),
     ]
+    options = _additional_pep517_args()
     if editable:
-        command.append("--editable")
-    pep517_args = get_maturin_pep517_args()
+        options.append("--editable")
+
+    pep517_args = get_maturin_pep517_args(config_settings)
     if pep517_args:
-        command.extend(pep517_args)
+        options.extend(pep517_args)
+
+    if "--compatibility" not in options and "--manylinux" not in options:
+        # default to off if not otherwise specified
+        options = ["--compatibility", "off", *options]
+
+    command = [*base_command, *options]
 
     print("Running `{}`".format(" ".join(command)))
     sys.stdout.flush()
-    result = subprocess.run(command, stdout=subprocess.PIPE)
+    result = subprocess.run(command, stdout=subprocess.PIPE, env=_get_env())
     sys.stdout.buffer.write(result.stdout)
     sys.stdout.flush()
     if result.returncode != 0:
-        sys.stderr.write(
-            f"Error: command {command} returned non-zero exit status {result.returncode}\n"
-        )
+        sys.stderr.write(f"Error: command {command} returned non-zero exit status {result.returncode}\n")
         sys.exit(1)
     output = result.stdout.decode(errors="replace")
     wheel_path = output.strip().splitlines()[-1]
@@ -73,41 +124,48 @@ def _build_wheel(
 
 
 # noinspection PyUnusedLocal
-def build_wheel(wheel_directory, config_settings=None, metadata_directory=None):
+def build_wheel(
+    wheel_directory: str,
+    config_settings: Optional[Mapping[str, Any]] = None,
+    metadata_directory: Optional[str] = None,
+) -> str:
     return _build_wheel(wheel_directory, config_settings, metadata_directory)
 
 
 # noinspection PyUnusedLocal
-def build_sdist(sdist_directory, config_settings=None):
+def build_sdist(sdist_directory: str, config_settings: Optional[Mapping[str, Any]] = None) -> str:
     command = ["maturin", "pep517", "write-sdist", "--sdist-directory", sdist_directory]
 
     print("Running `{}`".format(" ".join(command)))
     sys.stdout.flush()
-    result = subprocess.run(command, stdout=subprocess.PIPE)
+    result = subprocess.run(command, stdout=subprocess.PIPE, env=_get_env())
     sys.stdout.buffer.write(result.stdout)
     sys.stdout.flush()
     if result.returncode != 0:
-        sys.stderr.write(
-            f"Error: command {command} returned non-zero exit status {result.returncode}\n"
-        )
+        sys.stderr.write(f"Error: command {command} returned non-zero exit status {result.returncode}\n")
         sys.exit(1)
     output = result.stdout.decode(errors="replace")
     return output.strip().splitlines()[-1]
 
 
 # noinspection PyUnusedLocal
-def get_requires_for_build_wheel(config_settings=None):
+def get_requires_for_build_wheel(config_settings: Optional[Mapping[str, Any]] = None) -> List[str]:
     if get_config().get("bindings") == "cffi":
-        return ["cffi"]
+        requirements = ["cffi"]
     else:
-        return []
+        requirements = []
+    if not os.environ.get("MATURIN_NO_INSTALL_RUST") and not shutil.which("cargo"):
+        requirements += ["puccinialin"]
+    return requirements
 
 
 # noinspection PyUnusedLocal
-def build_editable(wheel_directory, config_settings=None, metadata_directory=None):
-    return _build_wheel(
-        wheel_directory, config_settings, metadata_directory, editable=True
-    )
+def build_editable(
+    wheel_directory: str,
+    config_settings: Optional[Mapping[str, Any]] = None,
+    metadata_directory: Optional[str] = None,
+) -> str:
+    return _build_wheel(wheel_directory, config_settings, metadata_directory, editable=True)
 
 
 # Requirements to build an editable are the same as for a wheel
@@ -115,18 +173,21 @@ get_requires_for_build_editable = get_requires_for_build_wheel
 
 
 # noinspection PyUnusedLocal
-def get_requires_for_build_sdist(config_settings=None):
-    return []
+def get_requires_for_build_sdist(config_settings: Optional[Mapping[str, Any]] = None) -> List[str]:
+    requirements = []
+    if not os.environ.get("MATURIN_NO_INSTALL_RUST") and not shutil.which("cargo"):
+        requirements += ["puccinialin"]
+    return requirements
 
 
 # noinspection PyUnusedLocal
-def prepare_metadata_for_build_wheel(metadata_directory, config_settings=None):
+def prepare_metadata_for_build_wheel(
+    metadata_directory: str, config_settings: Optional[Mapping[str, Any]] = None
+) -> str:
     print("Checking for Rust toolchain....")
     is_cargo_installed = False
     try:
-        output = subprocess.check_output(["cargo", "--version"]).decode(
-            "utf-8", "ignore"
-        )
+        output = subprocess.check_output(["cargo", "--version"], env=_get_env()).decode("utf-8", "ignore")
         if "cargo" in output:
             is_cargo_installed = True
     except (FileNotFoundError, SubprocessError):
@@ -149,21 +210,22 @@ def prepare_metadata_for_build_wheel(metadata_directory, config_settings=None):
         # PEP 517 specifies that only `sys.executable` points to the correct
         # python interpreter
         "--interpreter",
-        sys.executable,
+        _get_sys_executable(),
     ]
-    pep517_args = get_maturin_pep517_args()
+    command.extend(_additional_pep517_args())
+    pep517_args = get_maturin_pep517_args(config_settings)
     if pep517_args:
         command.extend(pep517_args)
 
     print("Running `{}`".format(" ".join(command)))
     try:
-        output = subprocess.check_output(command)
+        _output = subprocess.check_output(command, env=_get_env())
     except subprocess.CalledProcessError as e:
         sys.stderr.write(f"Error running maturin: {e}\n")
         sys.exit(1)
-    sys.stdout.buffer.write(output)
+    sys.stdout.buffer.write(_output)
     sys.stdout.flush()
-    output = output.decode(errors="replace")
+    output = _output.decode(errors="replace")
     return output.strip().splitlines()[-1]
 
 

maturin/__main__.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+import sysconfig
+from typing import Optional
+
+
+def get_maturin_path() -> Optional[Path]:
+    SCRIPT_NAME = "maturin"
+
+    def script_dir(scheme: str) -> str:
+        return sysconfig.get_path("scripts", scheme)
+
+    def script_exists(dir: str) -> bool:
+        for _, _, files in os.walk(dir):
+            for f in files:
+                name, *_ = os.path.splitext(f)
+                if name == SCRIPT_NAME:
+                    return True
+
+        return False
+
+    paths = list(
+        filter(
+            script_exists,
+            filter(os.path.exists, map(script_dir, sysconfig.get_scheme_names())),
+        )
+    )
+
+    if paths:
+        return Path(paths[0]) / SCRIPT_NAME
+
+    return None
+
+
+if __name__ == "__main__":
+    maturin = get_maturin_path()
+    if maturin is None:
+        print("Unable to find `maturin` script")
+        exit(1)
+
+    if sys.platform == "win32":
+        import subprocess
+
+        code = subprocess.call([str(maturin)] + sys.argv[1:])
+        sys.exit(code)
+    else:
+        os.execv(maturin, [str(maturin)] + sys.argv[1:])

maturin/bootstrap.py

@@ -0,0 +1,31 @@
+"""Support installing rust before compiling (bootstrapping) maturin.
+
+Installing a package that uses maturin as build backend on a platform without maturin
+binaries, we install rust in a cache directory if the user doesn't have a rust
+installation already. Since this bootstrapping requires more dependencies but is only
+required if rust is missing, we check if cargo is present before requesting those
+dependencies.
+
+https://setuptools.pypa.io/en/stable/build_meta.html#dynamic-build-dependencies-and-other-build-meta-tweaks
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+from typing import Any
+
+# noinspection PyUnresolvedReferences
+from setuptools.build_meta import *  # noqa:F403
+
+
+def get_requires_for_build_wheel(config_settings: dict[str, Any] | None = None) -> list[str]:
+    if not os.environ.get("MATURIN_NO_INSTALL_RUST") and not shutil.which("cargo"):
+        return ["puccinialin>=0.1,<0.2"]
+    return []
+
+
+def get_requires_for_build_sdist(config_settings: dict[str, Any] | None = None) -> list[str]:
+    if not os.environ.get("MATURIN_NO_INSTALL_RUST") and not shutil.which("cargo"):
+        return ["puccinialin>=0.1,<0.2"]
+    return []

maturin-1.11.4.dist-info/METADATA

@@ -0,0 +1,303 @@
+Metadata-Version: 2.4
+Name: maturin
+Version: 1.11.4
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Programming Language :: Python :: Implementation :: GraalPy
+Requires-Dist: tomli>=1.1.0 ; python_full_version < '3.11'
+Requires-Dist: patchelf ; extra == 'patchelf'
+Requires-Dist: ziglang>=0.10.0,<0.13.0 ; extra == 'zig'
+Provides-Extra: patchelf
+Provides-Extra: zig
+License-File: license-mit
+License-File: license-apache
+Summary: Build and publish crates with pyo3, cffi and uniffi bindings as well as rust binaries as python packages
+Home-Page: https://github.com/pyo3/maturin
+Author-email: konstin <konstin@mailbox.org>
+License-Expression: MIT OR Apache-2.0
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Project-URL: Changelog, https://maturin.rs/changelog.html
+Project-URL: Documentation, https://maturin.rs
+Project-URL: Issues, https://github.com/PyO3/maturin/issues
+Project-URL: Source Code, https://github.com/PyO3/maturin
+
+# Maturin
+
+_formerly pyo3-pack_
+
+[![Maturin User Guide](https://img.shields.io/badge/user-guide-brightgreen?logo=readthedocs&style=flat-square)](https://maturin.rs)
+[![Crates.io](https://img.shields.io/crates/v/maturin.svg?logo=rust&style=flat-square)](https://crates.io/crates/maturin)
+[![PyPI](https://img.shields.io/pypi/v/maturin.svg?logo=python&style=flat-square)](https://pypi.org/project/maturin)
+[![discord server](https://img.shields.io/discord/1209263839632424990?logo=discord&style=flat-square)](https://discord.gg/33kcChzH7f)
+
+Build and publish crates with [pyo3, cffi and uniffi bindings](https://maturin.rs/bindings) as well as rust binaries as python packages with minimal configuration.
+It supports building wheels for python 3.8+ on Windows, Linux, macOS and FreeBSD, can upload them to [pypi](https://pypi.org/) and has basic PyPy and GraalPy support.
+
+Check out the [User Guide](https://maturin.rs/)!
+
+## Usage
+
+You can either download binaries from the [latest release](https://github.com/PyO3/maturin/releases/latest) or install it with [pipx](https://pypa.github.io/pipx/) or [uv](https://github.com/astral-sh/uv):
+
+```shell
+# pipx
+pipx install maturin
+# uv
+uv tool install maturin
+```
+
+> [!NOTE]
+>
+> `pip install maturin` should also work if you don't want to use pipx.
+
+There are three main commands:
+
+- `maturin new` creates a new cargo project with maturin configured.
+- `maturin build` builds the wheels and stores them in a folder (`target/wheels` by default), but doesn't upload them. It's recommended to publish packages with [uv](https://github.com/astral-sh/uv) using `uv publish`.
+- `maturin develop` builds the crate and installs it as a python module directly in the current virtualenv. Note that while `maturin develop` is faster, it doesn't support all the feature that running `pip install` after `maturin build` supports.
+
+maturin doesn't need extra configuration files and doesn't clash with an existing setuptools-rust configuration.
+You can even integrate it with testing tools such as [tox](https://tox.readthedocs.io/en/latest/).
+There are examples for the different bindings in the `test-crates` folder.
+
+The name of the package will be the name of the cargo project, i.e. the name field in the `[package]` section of `Cargo.toml`.
+The name of the module, which you are using when importing, will be the `name` value in the `[lib]` section (which defaults to the name of the package). For binaries, it's simply the name of the binary generated by cargo.
+
+When using `maturin build` and `maturin develop` commands, you can compile a performance-optimized program by adding the `-r` or `--release` flag.
+
+## Python packaging basics
+
+Python packages come in two formats:
+A built form called wheel and source distributions (sdist), both of which are archives.
+A wheel can be compatible with any python version, interpreter (cpython and pypy, mainly), operating system and hardware architecture (for pure python wheels),
+can be limited to a specific platform and architecture (e.g. when using ctypes or cffi) or to a specific python interpreter and version on a specific architecture and operating system (e.g. with pyo3).
+
+When using `pip install` on a package, pip tries to find a matching wheel and install that. If it doesn't find one, it downloads the source distribution and builds a wheel for the current platform,
+which requires the right compilers to be installed. Installing a wheel is much faster than installing a source distribution as building wheels is generally slow.
+
+When you publish a package to be installable with `pip install`, you upload it to [pypi](https://pypi.org/), the official package repository.
+For testing, you can use [test pypi](https://test.pypi.org/) instead, which you can use with `pip install --index-url https://test.pypi.org/simple/`.
+Note that for [publishing for linux](#manylinux-and-auditwheel), you need to use the manylinux docker container or zig, while for publishing from your repository you can use the [PyO3/maturin-action](https://github.com/PyO3/maturin-action) github action.
+
+## Mixed rust/python projects
+
+To create a mixed rust/python project, create a folder with your module name (i.e. `lib.name` in Cargo.toml) next to your Cargo.toml and add your python sources there:
+
+```
+my-project
+├── Cargo.toml
+├── my_project
+│   ├── __init__.py
+│   └── bar.py
+├── pyproject.toml
+├── README.md
+└── src
+    └── lib.rs
+```
+
+You can specify a different python source directory in `pyproject.toml` by setting `tool.maturin.python-source`, for example
+
+**pyproject.toml**
+
+```toml
+[tool.maturin]
+python-source = "python"
+module-name = "my_project._lib_name"
+```
+
+then the project structure would look like this:
+
+```
+my-project
+├── Cargo.toml
+├── python
+│   └── my_project
+│       ├── __init__.py
+│       └── bar.py
+├── pyproject.toml
+├── README.md
+└── src
+    └── lib.rs
+```
+
+> [!NOTE]
+>
+> This structure is recommended to avoid [a common `ImportError` pitfall](https://github.com/PyO3/maturin/issues/490)
+
+maturin will add the native extension as a module in your python folder. When using develop, maturin will copy the native library and for cffi also the glue code to your python folder. You should add those files to your gitignore.
+
+With cffi you can do `from .my_project import lib` and then use `lib.my_native_function`, with pyo3 you can directly `from .my_project import my_native_function`.
+
+Example layout with pyo3 after `maturin develop`:
+
+```
+my-project
+├── Cargo.toml
+├── my_project
+│   ├── __init__.py
+│   ├── bar.py
+│   └── _lib_name.cpython-36m-x86_64-linux-gnu.so
+├── README.md
+└── src
+    └── lib.rs
+```
+
+When doing this also be sure to set the module name in your code to match the last part of `module-name` (don't include the package path):
+
+```rust
+#[pymodule]
+#[pyo3(name="_lib_name")]
+fn my_lib_name(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_class::<MyPythonRustClass>()?;
+    Ok(())
+}
+```
+
+## Python metadata
+
+maturin supports [PEP 621](https://www.python.org/dev/peps/pep-0621/), you can specify python package metadata in `pyproject.toml`.
+maturin merges metadata from `Cargo.toml` and `pyproject.toml`, `pyproject.toml` takes precedence over `Cargo.toml`.
+
+To specify python dependencies, add a list `dependencies` in a `[project]` section in the `pyproject.toml`. This list is equivalent to `install_requires` in setuptools:
+
+```toml
+[project]
+name = "my-project"
+dependencies = ["flask~=1.1.0", "toml>=0.10.2,<0.11.0"]
+```
+
+You can add so called console scripts, which are shell commands that execute some function in your program in the `[project.scripts]` section.
+The keys are the script names while the values are the path to the function in the format `some.module.path:class.function`, where the `class` part is optional. The function is called with no arguments. Example:
+
+```toml
+[project.scripts]
+get_42 = "my_project:DummyClass.get_42"
+```
+
+You can also specify [trove classifiers](https://pypi.org/classifiers/) in your `pyproject.toml` under `project.classifiers`:
+
+```toml
+[project]
+name = "my-project"
+classifiers = ["Programming Language :: Python"]
+```
+
+## Source distribution
+
+maturin supports building through `pyproject.toml`. To use it, create a `pyproject.toml` next to your `Cargo.toml` with the following content:
+
+```toml
+[build-system]
+requires = ["maturin>=1.0,<2.0"]
+build-backend = "maturin"
+```
+
+If a `pyproject.toml` with a `[build-system]` entry is present, maturin can build a source distribution of your package when `--sdist` is specified.
+The source distribution will contain the same files as `cargo package`. To only build a source distribution, pass `--interpreter` without any values.
+
+You can then e.g. install your package with `pip install .`. With `pip install . -v` you can see the output of cargo and maturin.
+
+You can use the options `compatibility`, `skip-auditwheel`, `bindings`, `strip` and common Cargo build options such as `features` under `[tool.maturin]` the same way you would when running maturin directly.
+The `bindings` key is required for cffi and bin projects as those can't be automatically detected. Currently, all builds are in release mode (see [this thread](https://discuss.python.org/t/pep-517-debug-vs-release-builds/1924) for details).
+
+For a non-manylinux build with cffi bindings you could use the following:
+
+```toml
+[build-system]
+requires = ["maturin>=1.0,<2.0"]
+build-backend = "maturin"
+
+[tool.maturin]
+bindings = "cffi"
+compatibility = "linux"
+```
+
+`manylinux` option is also accepted as an alias of `compatibility` for backward compatibility with old version of maturin.
+
+To include arbitrary files in the sdist for use during compilation specify `include` as an array of `path` globs with `format` set to `sdist`:
+
+```toml
+[tool.maturin]
+include = [{ path = "path/**/*", format = "sdist" }]
+```
+
+There's a `maturin sdist` command for only building a source distribution as workaround for [pypa/pip#6041](https://github.com/pypa/pip/issues/6041).
+
+## Manylinux and auditwheel
+
+For portability reasons, native python modules on linux must only dynamically link a set of very few libraries which are installed basically everywhere, hence the name manylinux.
+The pypa offers special docker images and a tool called [auditwheel](https://github.com/pypa/auditwheel/) to ensure compliance with the [manylinux rules](https://peps.python.org/pep-0599/#the-manylinux2014-policy).
+If you want to publish widely usable wheels for linux pypi, **you need to use a manylinux docker image or build with zig**.
+
+The Rust compiler since version 1.64 [requires at least glibc 2.17](https://blog.rust-lang.org/2022/08/01/Increasing-glibc-kernel-requirements.html), so you need to use at least manylinux2014.
+For publishing, we recommend enforcing the same manylinux version as the image with the manylinux flag, e.g. use `--manylinux 2014` if you are building in `quay.io/pypa/manylinux2014_x86_64`.
+The [PyO3/maturin-action](https://github.com/PyO3/maturin-action) github action already takes care of this if you set e.g. `manylinux: 2014`.
+
+maturin contains a reimplementation of auditwheel automatically checks the generated library and gives the wheel the proper platform tag.
+If your system's glibc is too new or you link other shared libraries, it will assign the `linux` tag.
+You can also manually disable those checks and directly use native linux target with `--manylinux off`.
+
+For full manylinux compliance you need to compile in a CentOS docker container. The [pyo3/maturin](https://ghcr.io/pyo3/maturin) image is based on the manylinux2014 image,
+and passes arguments to the `maturin` binary. You can use it like this:
+
+```
+docker run --rm -v $(pwd):/io ghcr.io/pyo3/maturin build --release  # or other maturin arguments
+```
+
+Note that this image is very basic and only contains python, maturin and stable rust. If you need additional tools, you can run commands inside the manylinux container.
+See [konstin/complex-manylinux-maturin-docker](https://github.com/konstin/complex-manylinux-maturin-docker) for a small educational example or [nanoporetech/fast-ctc-decode](https://github.com/nanoporetech/fast-ctc-decode/blob/b226ea0f2b2f4f474eff47349703d57d2ea4801b/.github/workflows/publish.yml) for a real world setup.
+
+maturin itself is manylinux compliant when compiled for the musl target.
+
+## Examples
+
+- [agg-python-bindings](https://pypi.org/project/agg-python-bindings) - A Python Library that binds to Asciinema Agg terminal record renderer and Avt terminal emulator
+- [ballista-python](https://github.com/apache/arrow-ballista-python) - A Python library that binds to Apache Arrow distributed query engine Ballista
+- [bleuscore](https://github.com/shenxiangzhuang/bleuscore) - A BLEU score calculation library, written in pure Rust
+- [chardetng-py](https://github.com/john-parton/chardetng-py) - Python binding for the chardetng character encoding detector.
+- [connector-x](https://github.com/sfu-db/connector-x/tree/main/connectorx-python) - ConnectorX enables you to load data from databases into Python in the fastest and most memory efficient way
+- [datafusion-python](https://github.com/apache/arrow-datafusion-python) - a Python library that binds to Apache Arrow in-memory query engine DataFusion
+- [deltalake-python](https://github.com/delta-io/delta-rs/tree/main/python) - Native Delta Lake Python binding based on delta-rs with Pandas integration
+- [opendal](https://github.com/apache/incubator-opendal/tree/main/bindings/python) - OpenDAL Python Binding to access data freely
+- [orjson](https://github.com/ijl/orjson) - A fast, correct JSON library for Python
+- [polars](https://github.com/pola-rs/polars/tree/master/py-polars) - Fast multi-threaded DataFrame library in Rust | Python | Node.js
+- [pydantic-core](https://github.com/pydantic/pydantic-core) - Core validation logic for pydantic written in Rust
+- [pyrus-cramjam](https://github.com/milesgranger/pyrus-cramjam) - Thin Python wrapper to de/compression algorithms in Rust
+- [pyxel](https://github.com/kitao/pyxel) - A retro game engine for Python
+- [roapi](https://github.com/roapi/roapi) - ROAPI automatically spins up read-only APIs for static datasets without requiring you to write a single line of code
+- [robyn](https://github.com/sansyrox/robyn) - A fast and extensible async python web server with a Rust runtime
+- [ruff](https://github.com/charliermarsh/ruff) - An extremely fast Python linter, written in Rust
+- [rnet](https://github.com/0x676e67/rnet) - Asynchronous Python HTTP Client with Black Magic
+- [rustpy-xlsxwriter](https://github.com/rahmadafandi/rustpy-xlsxwriter): A high-performance Python library for generating Excel files, utilizing the [rust_xlsxwriter](https://github.com/jmcnamara/rust_xlsxwriter) crate for efficient data handling.
+- [tantivy-py](https://github.com/quickwit-oss/tantivy-py) - Python bindings for Tantivy
+- [tpchgen-cli](https://github.com/clflushopt/tpchgen-rs/tree/main/tpchgen-cli) - Python CLI binding for `tpchgen`, a blazing fast TPC-H benchmark data generator built in pure Rust with zero dependencies.
+- [watchfiles](https://github.com/samuelcolvin/watchfiles) - Simple, modern and high performance file watching and code reload in python
+- [wonnx](https://github.com/webonnx/wonnx/tree/master/wonnx-py) - Wonnx is a GPU-accelerated ONNX inference run-time written 100% in Rust
+
+## Contributing
+
+Everyone is welcomed to contribute to maturin! There are many ways to support the project, such as:
+
+- help maturin users with issues on GitHub and Gitter
+- improve documentation
+- write features and bugfixes
+- publish blogs and examples of how to use maturin
+
+Our [contributing notes](https://github.com/PyO3/maturin/blob/main/guide/src/contributing.md) have more resources if you wish to volunteer time for maturin and are searching where to start.
+
+If you don't have time to contribute yourself but still wish to support the project's future success, some of our maintainers have GitHub sponsorship pages:
+
+- [messense](https://github.com/sponsors/messense)
+
+## License
+
+Licensed under either of:
+
+- Apache License, Version 2.0, ([LICENSE-APACHE](https://github.com/PyO3/maturin/blob/main/license-apache) or http://www.apache.org/licenses/LICENSE-2.0)
+- MIT license ([LICENSE-MIT](https://github.com/PyO3/maturin/blob/main/license-mit) or http://opensource.org/licenses/MIT)
+
+at your option.
+

maturin-1.11.4.dist-info/RECORD

@@ -0,0 +1,9 @@
+maturin\__init__.py,sha256=tmumBl4GgA-QUC-ObzHYLKQ-9JQ7m5NbzP-OpWmAjDs,8345
+maturin\__main__.py,sha256=UxDvFV1Hhu0gW_Jvb6Kzdc78gg7zjUUiZBhWrpLi5YU,1195
+maturin\bootstrap.py,sha256=UJX3a3qom4hOf8S4u6RnQPxE7ryTaZHKhRDWvbgFgVA,1203
+maturin-1.11.4.data\scripts\maturin.exe,sha256=UJJiqmnyEjo8ucOjq0EZG8Ld48-brjIOGAUZSxrKI_A,23134208
+maturin-1.11.4.dist-info\METADATA,sha256=SKb3oxrduBKBXTvSFQxozBZfNK1405tb9DzUthnWIxg,16938
+maturin-1.11.4.dist-info\WHEEL,sha256=hhuDfKhPIdoq9ysh1ECp2NTjQKFHwXNZaTMv0v1fH54,94
+maturin-1.11.4.dist-info\licenses\license-apache,sha256=fP1zjFPWHHnwfjSPYiv3cHyQhCNwVNN_vgd4inX1iBw,11048
+maturin-1.11.4.dist-info\licenses\license-mit,sha256=wxQ4V_npq8yxG5GzJOXtW7v4FLAIvyJJxDkw66h_CTs,1076
+maturin-1.11.4.dist-info\RECORD,,

{maturin-0.12.19.dist-info → maturin-1.11.4.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: maturin (0.12.19)
+Generator: maturin (1.11.4)
 Root-Is-Purelib: false
 Tag: py3-none-win_amd64