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

maturin-1.11.5.dist-info/licenses/license-apache

@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

maturin-1.11.5.dist-info/licenses/license-mit

@@ -0,0 +1,25 @@
+Copyright (c) 2018 konstin
+
+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.

maturin/import_hook.py

@@ -1,152 +0,0 @@
-import contextlib
-import importlib
-import importlib.util
-from importlib import abc
-from importlib.machinery import ModuleSpec
-import os
-import pathlib
-import shutil
-import sys
-import subprocess
-from typing import Optional
-
-try:
-    import tomllib
-except ModuleNotFoundError:
-    import tomli as tomllib
-
-
-class Importer(abc.MetaPathFinder):
-    """A meta-path importer for the maturin based packages"""
-
-    def __init__(self, bindings: Optional[str] = None, release: bool = False):
-        self.bindings = bindings
-        self.release = release
-
-    def find_spec(self, fullname, path, target=None):
-        if fullname in sys.modules:
-            return
-        mod_parts = fullname.split(".")
-        module_name = mod_parts[-1]
-
-        cwd = pathlib.Path(os.getcwd())
-        # Full Cargo project in cwd
-        cargo_toml = cwd / "Cargo.toml"
-        if _is_cargo_project(cargo_toml, module_name):
-            return self._build_and_load(fullname, cargo_toml)
-
-        # Full Cargo project in subdirectory of cwd
-        cargo_toml = cwd / module_name / "Cargo.toml"
-        if _is_cargo_project(cargo_toml, module_name):
-            return self._build_and_load(fullname, cargo_toml)
-        # module name with '-' instead of '_'
-        cargo_toml = cwd / module_name.replace("_", "-") / "Cargo.toml"
-        if _is_cargo_project(cargo_toml, module_name):
-            return self._build_and_load(fullname, cargo_toml)
-
-        # Single .rs file
-        rust_file = cwd / (module_name + ".rs")
-        if rust_file.exists():
-            project_dir = generate_project(rust_file, bindings=self.bindings or "pyo3")
-            cargo_toml = project_dir / "Cargo.toml"
-            return self._build_and_load(fullname, cargo_toml)
-
-    def _build_and_load(self, fullname: str, cargo_toml: pathlib.Path) -> ModuleSpec:
-        build_module(cargo_toml, bindings=self.bindings)
-        loader = Loader(fullname)
-        return importlib.util.spec_from_loader(fullname, loader)
-
-
-class Loader(abc.Loader):
-    def __init__(self, fullname):
-        self.fullname = fullname
-
-    def load_module(self, fullname):
-        return importlib.import_module(self.fullname)
-
-
-def _is_cargo_project(cargo_toml: pathlib.Path, module_name: str) -> bool:
-    with contextlib.suppress(FileNotFoundError):
-        with open(cargo_toml, "rb") as f:
-            cargo = tomllib.load(f)
-            package_name = cargo.get("package", {}).get("name")
-            if (
-                package_name == module_name
-                or package_name.replace("-", "_") == module_name
-            ):
-                return True
-    return False
-
-
-def generate_project(rust_file: pathlib.Path, bindings: str = "pyo3") -> pathlib.Path:
-    build_dir = pathlib.Path(os.getcwd()) / "build"
-    project_dir = build_dir / rust_file.stem
-    if project_dir.exists():
-        shutil.rmtree(project_dir)
-
-    command = ["maturin", "new", "-b", bindings, project_dir]
-    result = subprocess.run(command, stdout=subprocess.PIPE)
-    if result.returncode != 0:
-        sys.stderr.write(
-            f"Error: command {command} returned non-zero exit status {result.returncode}\n"
-        )
-        raise ImportError("Failed to generate cargo project")
-
-    with open(rust_file) as f:
-        lib_rs_content = f.read()
-    lib_rs = project_dir / "src" / "lib.rs"
-    with open(lib_rs, "w") as f:
-        f.write(lib_rs_content)
-    return project_dir
-
-
-def build_module(
-    manifest_path: pathlib.Path, bindings: Optional[str] = None, release: bool = False
-):
-    command = ["maturin", "develop", "-m", manifest_path]
-    if bindings:
-        command.append("-b")
-        command.append(bindings)
-    if release:
-        command.append("--release")
-    result = subprocess.run(command, stdout=subprocess.PIPE)
-    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"
-        )
-        raise ImportError("Failed to build module with maturin")
-
-
-def _have_importer() -> bool:
-    for importer in sys.meta_path:
-        if isinstance(importer, Importer):
-            return True
-    return False
-
-
-def install(bindings: Optional[str] = None, release: bool = False):
-    """
-    Install the import hook.
-
-    :param bindings: Which kind of bindings to use.
-        Possible values are pyo3, rust-cpython and cffi
-
-    :param release: Build in release mode, otherwise debug mode by default
-    """
-    if _have_importer():
-        return
-    importer = Importer(bindings=bindings, release=release)
-    sys.meta_path.append(importer)
-    return importer
-
-
-def uninstall(importer: Importer):
-    """
-    Uninstall the import hook.
-    """
-    try:
-        sys.meta_path.remove(importer)
-    except ValueError:
-        pass

maturin-0.12.19.dist-info/METADATA

@@ -1,284 +0,0 @@
-Metadata-Version: 2.1
-Name: maturin
-Version: 0.12.19
-Classifier: Topic :: Software Development :: Build Tools
-Classifier: Programming Language :: Rust
-Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Dist: tomli>=1.1.0 ; python_version<'3.11'
-Requires-Dist: ziglang~=0.9.0; extra == 'zig'
-Requires-Dist: patchelf; extra == 'patchelf'
-Provides-Extra: zig
-Provides-Extra: patchelf
-Summary: Build and publish crates with pyo3, rust-cpython and cffi bindings as well as rust binaries as python packages
-Keywords: python,cffi,packaging,pypi,pyo3
-Home-Page: https://github.com/pyo3/maturin
-Author: konstin <konstin@mailbox.org>, messense <messense@icloud.com>
-Author-email: konstin <konstin@mailbox.org>, messense <messense@icloud.com>
-License: MIT OR Apache-2.0
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
-Project-URL: Issues, https://github.com/PyO3/maturin/issues
-Project-URL: Changelog, https://maturin.rs/changelog.html
-Project-URL: Source Code, https://github.com/PyO3/maturin
-Project-URL: Documentation, https://maturin.rs
-
-# Maturin
-
-_formerly pyo3-pack_
-
-[![Actions Status](https://github.com/PyO3/maturin/workflows/Run%20tests/badge.svg)](https://github.com/PyO3/maturin/actions)
-[![FreeBSD](https://img.shields.io/cirrus/github/PyO3/maturin/main?style=flat-square)](https://cirrus-ci.com/github/PyO3/maturin)
-[![Crates.io](https://img.shields.io/crates/v/maturin.svg?style=flat-square)](https://crates.io/crates/maturin)
-[![PyPI](https://img.shields.io/pypi/v/maturin.svg?style=flat-square)](https://pypi.org/project/maturin/)
-[![Maturin User Guide](https://img.shields.io/badge/user-guide-brightgreen?style=flat-square)](https://maturin.rs/)
-[![Chat on Gitter](https://img.shields.io/gitter/room/nwjs/nw.js.svg?style=flat-square)](https://gitter.im/PyO3/Lobby)
-
-Build and publish crates with pyo3, rust-cpython and cffi bindings as well as rust binaries as python packages.
-
-This project is meant as a zero configuration replacement for [setuptools-rust](https://github.com/PyO3/setuptools-rust) and [milksnake](https://github.com/getsentry/milksnake).
-It supports building wheels for python 3.5+ on windows, linux, mac and freebsd, can upload them to [pypi](https://pypi.org/) and has basic pypy 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 pip:
-
-```shell
-pip install maturin
-```
-
-There are four main commands:
-
- * `maturin new` creates a new cargo project with maturin configured.
- * `maturin publish` builds the crate into python packages and publishes them to pypi.
- * `maturin build` builds the wheels and stores them in a folder (`target/wheels` by default), but doesn't upload them. It's possible to upload those with [twine](https://github.com/pypa/twine) or `maturin upload`.
- * `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.
-
-`pyo3` and `rust-cpython` bindings are automatically detected, for cffi or binaries you need to pass `-b cffi` or `-b bin`.
-maturin doesn't need extra configuration files and doesn't clash with an existing setuptools-rust or milksnake 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.
-
-## 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 and rust-cpython).
-
-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, [you need to use the manylinux docker container](#manylinux-and-auditwheel), while for publishing from your repository you can use the [messense/maturin-action github action](https://github.com/messense/maturin-action).
-
-## pyo3 and rust-cpython
-
-For pyo3 and rust-cpython, maturin can only build packages for installed python versions. On linux and mac, all python versions in `PATH` are used.
-If you don't set your own interpreters with `-i`, a heuristic is used to search for python installations.
-On windows all versions from the python launcher (which is installed by default by the python.org installer) and all conda environments except base are used. You can check which versions are picked up with the `list-python` subcommand.
-
-pyo3 will set the used python interpreter in the environment variable `PYTHON_SYS_EXECUTABLE`, which can be used from custom build scripts. Maturin can build and upload wheels for pypy with pyo3, even though only pypy3.7-7.3 on linux is tested.
-
-## Cffi
-
-Cffi wheels are compatible with all python versions including pypy. If `cffi` isn't installed and python is running inside a virtualenv, maturin will install it, otherwise you have to install it yourself (`pip install cffi`).
-
-maturin uses cbindgen to generate a header file, which can be customized by configuring cbindgen through a `cbindgen.toml` file inside your project root. Alternatively you can use a build script that writes a header file to `$PROJECT_ROOT/target/header.h`.
-
-Based on the header file maturin generates a module which exports an `ffi` and a `lib` object.
-
-<details>
-<summary>Example of a custom build script</summary>
-
-```rust
-use cbindgen;
-use std::env;
-use std::path::Path;
-
-fn main() {
-    let crate_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
-
-    let bindings = cbindgen::Builder::new()
-        .with_no_includes()
-        .with_language(cbindgen::Language::C)
-        .with_crate(crate_dir)
-        .generate()
-        .unwrap();
-    bindings.write_to_file(Path::new("target").join("header.h"));
-}
-```
-
-</details>
-
-## 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 `Cargo.toml` by setting `package.metadata.maturin.python-source`, for example
-
-```toml
-[package.metadata.maturin]
-python-source = "python"
-```
-
-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
-```
-
-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/rust-cpython 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
-│   └── my_project.cpython-36m-x86_64-linux-gnu.so
-├── Readme.md
-└── src
-    └── lib.rs
-```
-
-## 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` take 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.0"]
-```
-
-Pip allows adding so called console scripts, which are shell commands that execute some function in you program. You can add console scripts in a section `[project.scripts]`.
-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 Cargo.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>=0.12,<0.13"]
-build-backend = "maturin"
-```
-
-If a `pyproject.toml` with a `[build-system]` entry is present, maturin will build a source distribution of your package, unless `--no-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`, `cargo-extra-args` and `rustc-extra-args` 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>=0.12,<0.13"]
-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 `sdist-include` as an array of globs:
-
-```toml
-[tool.maturin]
-sdist-include = ["path/**/*"]
-```
-
-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://www.python.org/dev/peps/pep-0571/#the-manylinux2010-policy).
-If you want to publish widely usable wheels for linux pypi, **you need to use a manylinux docker image**.
-
-The Rust compiler since version 1.47 [requires at least glibc 2.11](https://github.com/rust-lang/rust/blob/master/RELEASES.md#version-1470-2020-10-08), so you need to use at least manylinux2010.
-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 [messense/maturin-action](https://github.com/messense/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.
-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 manylinux2010 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.
-
-## Code
-
-The main part is the maturin library, which is completely documented and should be well integrable. The accompanying `main.rs` takes care username and password for the pypi upload and otherwise calls into the library.
-
-The `sysconfig` folder contains the output of `python -m sysconfig` for different python versions and platform, which is helpful during development.
-
-You need to install `cffi` and `virtualenv` (`pip install cffi virtualenv`) to run the tests.
-
-There are some optional hacks that can speed up the tests (over 80s to 17s on my machine).
-1. By running `cargo build --release --manifest-path test-crates/cargo-mock/Cargo.toml` you can activate a cargo cache avoiding to rebuild the pyo3 test crates with every python version.
-2. Delete `target/test-cache` to clear the cache (e.g. after changing a test crate) or remove `test-crates/cargo-mock/target/release/cargo` to deactivate it.
-3. By running the tests with the `faster-tests` feature, binaries are stripped and wheels are only stored and not compressed.
-

maturin-0.12.19.dist-info/RECORD

@@ -1,6 +0,0 @@
-maturin-0.12.19.dist-info/METADATA,sha256=cms-zhifDbMbgx3PfmmC7kC50hhl_zJhGoe_uXQaL_A,15476
-maturin-0.12.19.dist-info/WHEEL,sha256=6OXUSsNrEQivqqFRVKBxqPQsdGI0KIVrJ1bSNlw7PXY,95
-maturin/import_hook.py,sha256=gFTAmQZBhoWvweXK5-ontQfqnVE-DTRJmnjIbn0bDUI,4987
-maturin/__init__.py,sha256=V4ISM-b_o3LnveoWtNCsCorRXtjPXo94tBuN1prAcEc,5467
-maturin-0.12.19.data/scripts/maturin.exe,sha256=LY5SKozDHN8s51Sz9D7VdjanCO_bKnnphx0ggGYdgAU,16143872
-maturin-0.12.19.dist-info/RECORD,,