pax_global_header00006660000000000000000000000064152553730370014524gustar00rootroot0000000000000052 comment=c8167c3ef1b54109a64511b1c77cf303f4c7830a pybind-pybind11-stubgen-c8167c3/000077500000000000000000000000001525537303700164435ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/.git-blame-ignore-revs000066400000000000000000000001221525537303700225360ustar00rootroot00000000000000ea663c34775284590aef5cf1d087fc1840edb027 abb3085624a1e982f360086b73686b8b32e47087 pybind-pybind11-stubgen-c8167c3/.github/000077500000000000000000000000001525537303700200035ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/.github/workflows/000077500000000000000000000000001525537303700220405ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/.github/workflows/ci.yml000066400000000000000000000202451525537303700231610ustar00rootroot00000000000000name: CI on: workflow_dispatch: pull_request: push: branches: - main tags: - "v*" jobs: check: name: Check runs-on: ubuntu-latest steps: - name: Checkout uses: actions/checkout@v5 - name: Setup Python 3.13 uses: actions/setup-python@v5 with: python-version: "3.13" - uses: astral-sh/setup-uv@v7 - name: Install requirements run: | uv lock --check uv sync - name: Run pre-commit run: uv run pre-commit run --all-files build: name: Build wheel runs-on: ubuntu-latest needs: [check] steps: - uses: actions/checkout@v5 - uses: actions/setup-python@v5 with: python-version: "3.13" - uses: astral-sh/setup-uv@v7 - name: Build sdist + wheel run: | uv lock --check uv build - name: Upload build artifacts uses: actions/upload-artifact@v6 with: name: dist path: dist tests: name: "Test 🐍 ${{ matrix.config.python }} • pybind-${{ matrix.config.pybind11-branch }} • ${{ matrix.config.numpy-format }}" runs-on: ubuntu-latest needs: [build] strategy: fail-fast: false matrix: config: [ { pybind11-branch: "v3.0", python: "3.13", numpy-format: "numpy-array-use-type-var", cmake-version: "4.2.x", }, { pybind11-branch: "v3.0", python: "3.13", numpy-format: "numpy-array-wrap-with-annotated", cmake-version: "4.2.x", }, { pybind11-branch: "v3.0", python: "3.12", numpy-format: "numpy-array-wrap-with-annotated", cmake-version: "4.2.x", }, { pybind11-branch: "v3.0", python: "3.11", numpy-format: "numpy-array-wrap-with-annotated", cmake-version: "4.2.x", }, { pybind11-branch: "v3.0", python: "3.10", numpy-format: "numpy-array-wrap-with-annotated", cmake-version: "4.2.x", }, { pybind11-branch: "v2.13", python: "3.13", numpy-format: "numpy-array-use-type-var", cmake-version: "4.2.x", }, { pybind11-branch: "v2.13", python: "3.13", numpy-format: "numpy-array-wrap-with-annotated", cmake-version: "4.2.x", }, { pybind11-branch: "v2.13", python: "3.12", numpy-format: "numpy-array-wrap-with-annotated", cmake-version: "4.2.x", }, { pybind11-branch: "v2.13", python: "3.11", numpy-format: "numpy-array-wrap-with-annotated", cmake-version: "4.2.x", }, { pybind11-branch: "v2.13", python: "3.10", numpy-format: "numpy-array-wrap-with-annotated", cmake-version: "4.2.x", }, { pybind11-branch: "v2.12", python: "3.13", numpy-format: "numpy-array-wrap-with-annotated", cmake-version: "3.28.3", }, { pybind11-branch: "v2.11", python: "3.13", numpy-format: "numpy-array-wrap-with-annotated", cmake-version: "3.28.3", }, { pybind11-branch: "v2.9", python: "3.13", numpy-format: "numpy-array-wrap-with-annotated", cmake-version: "3.28.3", }, ] steps: - uses: actions/checkout@v5 - name: Download build artifacts uses: actions/download-artifact@v6 with: name: dist path: dist - name: Setup Python ${{ matrix.config.python }} uses: actions/setup-python@v5 with: python-version: ${{ matrix.config.python }} - uses: astral-sh/setup-uv@v7 - name: Update CMake uses: jwlawson/actions-setup-cmake@v2 with: cmake-version: ${{ matrix.config.cmake-version }} - name: Create UV venv run: | uv venv .venv - name: Setup annotations on Linux if: runner.os == 'Linux' run: uv pip install pytest-github-actions-annotate-failures - name: Install requirements run: uv sync --group dev --no-install-project - name: Install shell: bash working-directory: dist run: uv pip install --disable-pip-version-check *.whl - name: Install demo module shell: bash run: | source .venv/bin/activate ./tests/install-demo-module.sh --pybind11-branch "${{ matrix.config.pybind11-branch }}" - name: Check stubs generation shell: bash run: | source .venv/bin/activate ./tests/check-demo-stubs-generation.sh --stubs-sub-dir "stubs/python-${{ matrix.config.python }}/pybind11-${{ matrix.config.pybind11-branch }}/${{ matrix.config.numpy-format }}" --${{ matrix.config.numpy-format }} - name: Archive patch uses: actions/upload-artifact@v6 if: failure() with: name: "python-${{ matrix.config.python }}-pybind-${{ matrix.config.pybind11-branch }}-${{ matrix.config.numpy-format }}.patch" path: "./tests/stubs/python-${{ matrix.config.python }}/pybind11-${{ matrix.config.pybind11-branch }}/${{ matrix.config.numpy-format }}.patch" retention-days: 30 if-no-files-found: ignore - name: Check error generation shell: bash run: | source .venv/bin/activate ./tests/check-demo-errors-generation.sh "pybind11-${{ matrix.config.pybind11-branch }}" test-cli-options: name: "Runs on 🐍 ${{ matrix.python }} • ${{ matrix.test-package }}" runs-on: ubuntu-latest needs: [build] strategy: fail-fast: false matrix: test-package: ["gemmi"] python: - "3.13" - "3.12" - "3.11" - "3.10" steps: - uses: actions/checkout@v5 - name: Setup Python ${{ matrix.python }} uses: actions/setup-python@v5 with: python-version: ${{ matrix.python }} - uses: astral-sh/setup-uv@v7 - name: Download build artifacts uses: actions/download-artifact@v6 with: name: dist path: dist - name: Create UV venv run: | uv venv .venv - name: Setup annotations on Linux if: runner.os == 'Linux' run: uv pip install pytest-github-actions-annotate-failures - name: Install shell: bash working-directory: dist run: uv pip install --disable-pip-version-check *.whl - name: "Install ${{ matrix.test-package }}" shell: bash run: uv pip install "${{ matrix.test-package }}" - name: Generate stubs shell: bash run: | source .venv/bin/activate pybind11-stubgen "${{ matrix.test-package }}" -o flavour-1 --numpy-array-wrap-with-annotated pybind11-stubgen "${{ matrix.test-package }}" -o flavour-2 --numpy-array-remove-parameters pybind11-stubgen "${{ matrix.test-package }}" -o flavour-3 --print-invalid-expressions-as-is pybind11-stubgen "${{ matrix.test-package }}" -o flavour-4 --numpy-array-use-type-var pybind11-stubgen "${{ matrix.test-package }}" --dry-run publish: name: Publish distribution needs: [check, build, tests, test-cli-options] if: github.event_name == 'push' && startsWith(github.event.ref, 'refs/tags') runs-on: ubuntu-latest permissions: # IMPORTANT: this permission is mandatory for Trusted Publishing id-token: write steps: - name: Download build artifacts uses: actions/download-artifact@v6 with: name: dist path: dist - name: Publish to PyPI uses: pypa/gh-action-pypi-publish@release/v1 pybind-pybind11-stubgen-c8167c3/.gitignore000066400000000000000000000067651525537303700204510ustar00rootroot00000000000000# Created by https://www.toptal.com/developers/gitignore/api/c++,cmake,python # Edit at https://www.toptal.com/developers/gitignore?templates=c++,cmake,python ### C++ ### # Prerequisites *.d # Compiled Object files *.slo *.lo *.o *.obj # Precompiled Headers *.gch *.pch # Compiled Dynamic libraries *.so *.dylib *.dll # Fortran module files *.mod *.smod # Compiled Static libraries *.lai *.la *.a *.lib # Executables *.exe *.out *.app ### CMake ### CMakeLists.txt.user CMakeCache.txt CMakeFiles CMakeScripts Testing Makefile cmake_install.cmake install_manifest.txt compile_commands.json CTestTestfile.cmake _deps ### CMake Patch ### # External projects *-prefix/ ### Python ### # Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] *$py.class # C extensions # Distribution / packaging .Python build/ develop-eggs/ dist/ downloads/ eggs/ .eggs/ lib/ lib64/ parts/ sdist/ var/ wheels/ share/python-wheels/ *.egg-info/ .installed.cfg *.egg MANIFEST # PyInstaller # Usually these files are written by a python script from a template # before PyInstaller builds the exe, so as to inject date/other infos into it. *.manifest *.spec # Installer logs pip-log.txt pip-delete-this-directory.txt # Unit test / coverage reports htmlcov/ .tox/ .nox/ .coverage .coverage.* .cache nosetests.xml coverage.xml *.cover *.py,cover .hypothesis/ .pytest_cache/ cover/ # Translations *.mo *.pot # Django stuff: *.log local_settings.py db.sqlite3 db.sqlite3-journal # Flask stuff: instance/ .webassets-cache # Scrapy stuff: .scrapy # Sphinx documentation docs/_build/ # PyBuilder .pybuilder/ target/ # Jupyter Notebook .ipynb_checkpoints # IPython profile_default/ ipython_config.py # pyenv # For a library or package, you might want to ignore these files since the code is # intended to run in multiple environments; otherwise, check them in: # .python-version # pipenv # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. # However, in case of collaboration, if having platform-specific dependencies or dependencies # having no cross-platform support, pipenv may install dependencies that don't work, or not # install all needed dependencies. #Pipfile.lock # poetry # Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. # This is especially recommended for binary packages to ensure reproducibility, and is more # commonly ignored for libraries. # https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control #poetry.lock # PEP 582; used by e.g. github.com/David-OConnor/pyflow __pypackages__/ # Celery stuff celerybeat-schedule celerybeat.pid # SageMath parsed files *.sage.py # Environments .env .venv env/ venv/ ENV/ env.bak/ venv.bak/ # Spyder project settings .spyderproject .spyproject # Rope project settings .ropeproject # mkdocs documentation /site # mypy .mypy_cache/ .dmypy.json dmypy.json # Pyre type checker .pyre/ # pytype static type analyzer .pytype/ # Cython debug symbols cython_debug/ # PyCharm # JetBrains specific template is maintainted in a separate JetBrains.gitignore that can # be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore # and can be added to the global gitignore or merged into this file. For a more nuclear # option (not recommended) you can uncomment the following to ignore the entire idea folder. .idea/ # End of https://www.toptal.com/developers/gitignore/api/c++,cmake,python # VS Code .vscode/ # Zed .zed/ tmp *.patch *.zip pybind-pybind11-stubgen-c8167c3/.pre-commit-config.yaml000066400000000000000000000007371525537303700227330ustar00rootroot00000000000000ci: autoupdate_schedule: quarterly repos: - repo: https://github.com/pre-commit/pre-commit-hooks rev: "v6.0.0" hooks: - id: check-yaml - id: end-of-file-fixer - id: trailing-whitespace - repo: https://github.com/astral-sh/ruff-pre-commit rev: v0.15.20 hooks: - id: ruff-check args: - --fix - --ignore=F401,F821 types_or: [ python, pyi ] - id: ruff-format types_or: [ python, pyi ] pybind-pybind11-stubgen-c8167c3/CHANGELOG.md000066400000000000000000000216401525537303700202570ustar00rootroot00000000000000Changelog ========= Version 3.0.0 (Sep 24, 2026) ---------------------------- Maintainership has passed from @sizmailov to @ax3l, @skarndev, and @virtuald, and the repository has been transferred to the pybind11 organization. Many thanks to @sizmailov for creating pybind11-stubgen and maintaining it over the years! Breaking changes: - ❗️ Require Python 3.10 or newer; drop support for Python 3.7–3.9 (#284, #285) by @ax3l and @gentlegiantJGC - ❗️ Disable `# value = ...` comments by default; use `--print-value-comments` to restore them (#251) by @dyollb and @ax3l Changes: - ✨ Support generating stubs for multiple modules in a single CLI invocation (#292) by @birgerbr - ✨ Add basic support for PEP 695 function type parameters in docstring signatures on Python 3.12+; class type parameters, variadics, and constraints are not supported (#291) by @gentlegiantJGC - ✨ Preserve docstrings for static properties exposed as fields, with Python 3.12+ and pybind11 2.10.1+ (#308) by @markuspi - 🐛 Order classes by dependencies rather than alphabetically, so base classes and class-body references appear before their dependents, including nested classes (#238) by @ax3l, @juelg, @daltairwalter, @skarndev, and @sizmailov - 🐛 Fix nested qualified names in pybind11 docstring signatures (#280) by @ax3l, @gentlegiantJGC, @sarlinpe, and @skarndev - 🐛 Strip current-module prefixes from nested type annotations and correctly parse runtime generic annotations (#301) by @ax3l - 🐛 Resolve hidden builtin types, such as `mappingproxy`, to their importable names in `types` (#278) by @skarndev and @ax3l - 🐛 Filter internal members of pybind11 native enums (#303) by @ax3l - 🐛 Avoid `RuntimeError: dictionary changed size during iteration` when attribute access modifies a class dictionary (#310) by @htruscott - 🐛 Make ordering of aliased and non-aliased imports deterministic (#293) by @cjwatson - 🐛 Remove unstable memory addresses from additional object representations, including `WeakKeyDictionary` (#295) by @ax3l - 🐛 Remove leading newlines from docstrings to avoid extra blank lines in generated stubs (#274) by @gentlegiantJGC Development: - 🔧 Move package metadata from `setup.py` to `pyproject.toml` (#281) by @gentlegiantJGC - 🔧 Add pybind11 3.0 test coverage and update expected stubs for pybind11 3.0.3 (#289, #296) by @gentlegiantJGC and @ax3l - 🔧 Add local test-stub regeneration via tox and fix demo builds on Clang/macOS (#287) by @skarndev and @ax3l - 🔧 Modernize CI and publishing, migrate development tooling to uv and Ruff, and automate pre-commit updates (#279, #283, #290, #307, #314) by @virtuald, @gentlegiantJGC, @skarndev, and @ax3l Version 2.5.5 (Aug 10, 2025) -------------------------- Changes: - 🐛 Fix the type annotation for `__all__` (#261) by @sarlinpe - 🐛 Handle boolean numpy arrays (#260) by @sarlinpe - 🐛 Fix `qualname` prefix in pybind11 3.0.0 (#259) by @gentlegiantJGC Version 2.5.4 (May 14, 2025) -------------------------- Changes: - ✨ Add `argv` to `main()` to simplify use as a library (#252) by @gentlegiantJGC - 🐛 Improve package detection (#253) by @gentlegiantJGC Version 2.5.3 (Feb 24, 2025) -------------------------- Changes: - ✨ Ignore technical dunder Python 3.13 fields (`__static_attributes__` and `__firstlineno__`): (#243) by @nim65s - 🔧 CI: Drop Python 3.7, add Python 3.13 (#243) by @nim65s Version 2.5.2 (Feb 24, 2025) -------------------------- Yanked to CI failure, released as 2.5.3 Version 2.5.1 (Mar 26, 2024) -------------------------- Changes: - 🐛 Fixed: Missed numpy unsigned int types (#219) by @Yc7521 Version 2.5 (Mar 3, 2024) -------------------------- Changes: - 🐛 Fixed: Don't render pybind11 `KeysView`, `ValuesView`, `ItemsView` class definitions (#211) - 🐛 Fixed: Escape backslashes in stub output (#208) Version 2.4.2 (Nov 27, 2023) -------------------------- Changes: - 🔁 Revert #196 due to poor review Version 2.4.1 (Nov 25, 2023) -------------------------- Changes: - ✨ Automatically replace invalid enum expressions with corresponding valid expression & import (#196) contributed by @ringohoffman - 🐛 Fixed: do not remove `self` parameter annotation when types do not match (#195) contributed by @ringohoffman Version 2.4 (Nov 21, 2023) -------------------------- Changes: - ✨ Added `--numpy-array-use-type-var` flag which reformats the pybind11-generated `numpy.ndarray[numpy.float32[m, 1]]` annotation as `numpy.ndarray[tuple[M, Literal[1]], numpy.dtype[numpy.float32]]` contributed by @ringohoffman (#188) Version 2.3.7 (Nov 18, 2023) -------------------------- Changes: - 🐛 fix: Handle top-level list-like annotations as types (#183) Version 2.3.6 (Oct 24, 2023) -------------------------- Changes: - 🐛 fix: Missing `py::dtype` translation (#179) Version 2.3.5 (Oct 23, 2023) -------------------------- Changes: - 🐛 fix: Wrong import for lowercase `buffer` (#175), issue (#173) Version 2.3.4 (Oct 23, 2023) -------------------------- Changes: - 🐛 fix: Misleading warning that referred to ignored errors (#171) Version 2.3.3 (Oct 22, 2023) -------------------------- Changes: - 🐛 fix: The `typing.Annotated` does not exist in python < 3.9, use `typing_extensions` (#168) Version 2.3.2 (Oct 21, 2023) -------------------------- Changes: - 🐛 fix: Missing function name in error message (#165) Version 2.3.1 (Oct 21, 2023) -------------------------- Changes: - 🐛 fix: Crash on `None`-valued docstring of property getter (#161) Version 2.3 (Sep 27, 2023) -------------------------- Changes: - 🐛 fix: Inconsistent `--enum-class-locations` behaviour (#158) Version 2.2.2 (Sep 26, 2023) -------------------------- Changes: - 🐛 fix: Missing `-?` in eum representation regex Version 2.2.1 (Sep 23, 2023) -------------------------- Changes: - 📝 Update `--print-invalid-expressions-as-is` description Version 2.2 (Sep 20, 2023) -------------------------- Changes: - 🐛 Fix: Python literals as default arg rendered as `...` (#147) - ✨ Add `--print-safe-value-reprs=REGEX` CLI option to override the print-safe flag of Value (for custom default value representations provided via `pybind11::arg_v()`) (#147) - ✨ Add `--enum-class-locations=REGEX:LOC` CLI option to rewrite enum values as valid Python expressions with correct imports. (#147) ⚠️ This release detects more invalid expressions in bindings code. Previously Enum-like representations (e.g. ``) were always treated as non-printable values and were rendered as `...`. The invalid expressions should be acknowledged by `--enum-class-locations` or `--ignore-invalid-expressions`. Version 2.1 (Sep 6, 2023) -------------------------- Changes: - ✨ Add `--stub-extension` CLI option (#142) Version 2.0.2 (Sep 4, 2023) -------------------------- Changes: - 🐛 Fix: missing `isinstance` check (#138) Version 2.0.1 (Sep 2, 2023) -------------------------- Changes: - 🐛 Fix: missing subdirectories for top-level submodules (#136) Version 2.0 (Sep 1, 2023) -------------------------- Changes: - 🐛 Explicitly set encoding of stubs to utf-8 (#133) - 🐛 Fix value representation for collections with print-unsafe elements (#132) Version 2.0.dev1 (Sep 1, 2023) -------------------------- Changes: - 🐛 Fix missing remap of `numpy.ndarray.flags` (#128) - ✨ Process `scipy.sparse.*` types the same as `numpy.ndarray` with `--numpy-array-wrap-with-annotated` (#128) - ✨ Support dynamic array size with `--numpy-array-wrap-with-annotated` (#128) - ❗️ Renamed CLI argument `--numpy-array-wrap-with-annotated-fixed-size` to `--numpy-array-wrap-with-annotated` (#128) Version 1.2 (Aug 31, 2023) -------------------------- Changes: - 🐛 Fix compatibility with Python 3.7..3.9 (#124) - 🐛 Fix incorrect list of base classes (#123) - ✨ Replace `typing` collections with builtin types (e.g. `typing.List` -> `list`) according to [PEP 585](https://peps.python.org/pep-0585/) (#122) - ✨ Add missing translations of pybind types: `function` -> `Callable`, `object`/`handle` -> `typing.Any` (#121) - ✨ Support function-valued default arguments (#119) - 🐛 Fix missing properties docstrings (#118) Version 1.1 (Aug 30, 2023) -------------------------- Changes: - Added `--dry-run` CLI option to skip writing stubs stage (#114 ) Version 1.0-dev (Aug 29, 2023) ------------------------------ ⚠️ Project was rewritten from scratch for `1.x`. This allowed me to address some long-standing issues, but I might accidentally brake behaviour you relied on. Changes: - Updated CLI interface, some options were removed, please see `pybind11-stubgen --help` for details - Replaced regex-based signature parsing with more robust procedure which enables to produce partially degraded signatures - Added type parsing/replacing, including deeply annotated types - Support implicit imports required for static analysis - Add introspection of pure python functions - Support python 3.10+ only (temporarily) - Improved structure of test binary pybind module pybind-pybind11-stubgen-c8167c3/LICENSE000066400000000000000000000042311525537303700174500ustar00rootroot00000000000000Copyright (c) 2019 Sergei Izmailov , All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. 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. 3. 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. You are under no obligation whatsoever to provide any bug fixes, patches, or upgrades to the features, functionality or performance of the source code ("Enhancements") to anyone; however, if you choose to make your Enhancements available either publicly, or directly to the author of this software, without imposing a separate written license agreement for such Enhancements, then you hereby grant the following license: a non-exclusive, royalty-free perpetual license to install, use, modify, prepare derivative works, incorporate into other computer software, distribute, and sublicense such enhancements or derivative works thereof, in binary and source code form. pybind-pybind11-stubgen-c8167c3/README.md000066400000000000000000000037371525537303700177340ustar00rootroot00000000000000[![pypi](https://img.shields.io/pypi/v/pybind11-stubgen.svg?logo=PyPI&logoColor=white)](https://pypi.org/project/pybind11-stubgen/) About ----- Static analysis tools and IDE usually struggle to understand python binary extensions. `pybind11-stubgen` generates [stubs](https://peps.python.org/pep-0561/) for python extensions to make them less opaque. While the CLI tool includes tweaks to target modules compiled specifically with [pybind11](https://github.com/pybind/pybind11) but it should work well with modules built with other libraries. ```bash # Install pip install pybind11-stubgen # Generate stubs for numpy pybind11-stubgen numpy ``` Usage ----- ``` pybind11-stubgen [-h] [-o OUTPUT_DIR] [--root-suffix ROOT_SUFFIX] [--ignore-invalid-expressions REGEX] [--ignore-invalid-identifiers REGEX] [--ignore-unresolved-names REGEX] [--ignore-all-errors] [--enum-class-locations REGEX:LOC] [--numpy-array-wrap-with-annotated| --numpy-array-use-type-var| --numpy-array-remove-parameters] [--print-invalid-expressions-as-is] [--print-value-comments] [--print-safe-value-reprs REGEX] [--exit-code] [--stub-extension EXT] MODULE_NAME [MODULE_NAMES ...] ``` Contributing ------------ During development, you may need to update the reference stubs in tests/stubs. This can be done locally using a convenience tox configuration. Ensure that all Python interpreters required by the test suite are available in your environment. For example, you can install them via uv: ```shell uv python install 3.10 3.11 3.12 3.13 ``` To enable the repository hooks locally: ```shell uv sync uv run pre-commit install ``` To regenerate the reference stubs run: ```shell uv venv source .venv/bin/activate uv tool install tox --with tox-uv uv run tox ``` pybind-pybind11-stubgen-c8167c3/pybind11_stubgen/000077500000000000000000000000001525537303700216215ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/pybind11_stubgen/__init__.py000066400000000000000000000271261525537303700237420ustar00rootroot00000000000000from __future__ import annotations import importlib import logging import re from argparse import ArgumentParser, Namespace from collections.abc import Sequence from pathlib import Path from pybind11_stubgen.parser.interface import IParser from pybind11_stubgen.parser.mixins.error_handlers import ( IgnoreAllErrors, IgnoreInvalidExpressionErrors, IgnoreInvalidIdentifierErrors, IgnoreUnresolvedNameErrors, LogErrors, LoggerData, SuggestCxxSignatureFix, TerminateOnFatalErrors, ) from pybind11_stubgen.parser.mixins.filter import ( FilterClassMembers, FilterInvalidIdentifiers, FilterPybind11NativeEnumMembers, FilterPybind11ViewClasses, FilterPybindInternals, FilterTypingModuleAttributes, ) from pybind11_stubgen.parser.mixins.fix import ( FixBuiltinTypes, FixCurrentModulePrefixInTypeNames, FixMissing__all__Attribute, FixMissing__future__AnnotationsImport, FixMissingEnumMembersAnnotation, FixMissingFieldDocString, FixMissingFixedSizeImport, FixMissingImports, FixMissingNoneHashFieldAnnotation, FixNumpyArrayDimAnnotation, FixNumpyArrayDimTypeVar, FixNumpyArrayFlags, FixNumpyArrayRemoveParameters, FixNumpyDtype, FixPEP585CollectionNames, FixPybind11EnumStrDoc, FixRedundantBuiltinsAnnotation, FixRedundantMethodsFromBuiltinObject, FixScipyTypeArguments, FixTypingTypeNames, FixValueReprRandomAddress, OverridePrintSafeValues, RemoveSelfAnnotation, ReplaceReadWritePropertyWithField, RewritePybind11EnumValueRepr, ) from pybind11_stubgen.parser.mixins.parse import ( BaseParser, ExtractSignaturesFromPybind11Docstrings, ParserDispatchMixin, ) from pybind11_stubgen.printer import Printer from pybind11_stubgen.structs import QualifiedName from pybind11_stubgen.writer import Writer class CLIArgs(Namespace): output_dir: str root_suffix: str ignore_invalid_expressions: re.Pattern | None ignore_invalid_identifiers: re.Pattern | None ignore_unresolved_names: re.Pattern | None ignore_all_errors: bool enum_class_locations: list[tuple[re.Pattern, str]] numpy_array_wrap_with_annotated: bool numpy_array_use_type_var: bool numpy_array_remove_parameters: bool print_invalid_expressions_as_is: bool print_safe_value_reprs: re.Pattern | None print_value_comments: bool exit_code: bool dry_run: bool stub_extension: str module_names: list[str] def arg_parser() -> ArgumentParser: def regex(pattern_str: str) -> re.Pattern: try: return re.compile(pattern_str) except re.error as e: raise ValueError(f"Invalid REGEX pattern: {e}") def regex_colon_path(regex_path: str) -> tuple[re.Pattern, str]: pattern_str, path = regex_path.rsplit(":", maxsplit=1) if any(not part.isidentifier() for part in path.split(".")): raise ValueError(f"Invalid PATH: {path}") return regex(pattern_str), path parser = ArgumentParser( prog="pybind11-stubgen", description="Generates stubs for specified modules" ) parser.add_argument( "-o", "--output-dir", help="The root directory for output stubs", default="./stubs", ) parser.add_argument( "--root-suffix", type=str, default=None, dest="root_suffix", help="Top-level module directory suffix", ) parser.add_argument( "--ignore-invalid-expressions", metavar="REGEX", default=None, type=regex, help="Ignore invalid expressions matching REGEX", ) parser.add_argument( "--ignore-invalid-identifiers", metavar="REGEX", default=None, type=regex, help="Ignore invalid identifiers matching REGEX", ) parser.add_argument( "--ignore-unresolved-names", metavar="REGEX", default=None, type=regex, help="Ignore unresolved names matching REGEX", ) parser.add_argument( "--ignore-all-errors", default=False, action="store_true", help="Ignore all errors during module parsing", ) parser.add_argument( "--enum-class-locations", dest="enum_class_locations", metavar="REGEX:LOC", action="append", default=[], type=regex_colon_path, help="Locations of enum classes in " ": format. " "Example: `MyEnum:foo.bar.Baz`", ) numpy_array_fix = parser.add_mutually_exclusive_group() numpy_array_fix.add_argument( "--numpy-array-wrap-with-annotated", default=False, action="store_true", help="Replace numpy/scipy arrays of " "'ARRAY_T[TYPE, [*DIMS], *FLAGS]' format with " "'Annotated[ARRAY_T, TYPE, FixedSize|DynamicSize(*DIMS), *FLAGS]'", ) numpy_array_fix.add_argument( "--numpy-array-use-type-var", default=False, action="store_true", help="Replace 'numpy.ndarray[numpy.float32[m, 1]]' with " "'numpy.ndarray[tuple[M, typing.Literal[1]], numpy.dtype[numpy.float32]]'", ) numpy_array_fix.add_argument( "--numpy-array-remove-parameters", default=False, action="store_true", help="Replace 'numpy.ndarray[...]' with 'numpy.ndarray'", ) parser.add_argument( "--print-invalid-expressions-as-is", default=False, action="store_true", help="Suppress the replacement with '...' of invalid expressions" "found in annotations", ) parser.add_argument( "--print-safe-value-reprs", metavar="REGEX", default=None, type=regex, help="Override the print-safe check for values matching REGEX", ) parser.add_argument( "--print-value-comments", default=False, action="store_true", help="Print attribute values as comments for debugging, " "i.e., '... # value = '", ) parser.add_argument( "--exit-code", action="store_true", dest="exit_code", help="On error exits with 1 and skips stub generation", ) parser.add_argument( "--dry-run", action="store_true", dest="dry_run", help="Don't write stubs. Parses module and report errors", ) parser.add_argument( "--stub-extension", type=str, default="pyi", metavar="EXT", choices=["pyi", "py"], help="The file extension of the generated stubs. " "Must be 'pyi' (default) or 'py'", ) parser.add_argument( "module_names", metavar="MODULE_NAMES", type=str, nargs="+", help="module names", ) return parser def stub_parser_from_args(args: CLIArgs) -> IParser: error_handlers_top: list[type] = [ LoggerData, *([IgnoreAllErrors] if args.ignore_all_errors else []), *([IgnoreInvalidIdentifierErrors] if args.ignore_invalid_identifiers else []), *([IgnoreInvalidExpressionErrors] if args.ignore_invalid_expressions else []), *([IgnoreUnresolvedNameErrors] if args.ignore_unresolved_names else []), ] error_handlers_bottom: list[type] = [ LogErrors, SuggestCxxSignatureFix, *([TerminateOnFatalErrors] if args.exit_code else []), ] numpy_fixes: list[type] = [ *([FixNumpyArrayDimAnnotation] if args.numpy_array_wrap_with_annotated else []), *([FixNumpyArrayDimTypeVar] if args.numpy_array_use_type_var else []), *( [FixNumpyArrayRemoveParameters] if args.numpy_array_remove_parameters else [] ), ] class Parser( *error_handlers_top, # type: ignore[misc] FixMissing__future__AnnotationsImport, FixMissing__all__Attribute, FixMissingNoneHashFieldAnnotation, FixMissingImports, FilterTypingModuleAttributes, FixPEP585CollectionNames, FixTypingTypeNames, FixScipyTypeArguments, FixMissingFieldDocString, FixMissingFixedSizeImport, FixMissingEnumMembersAnnotation, OverridePrintSafeValues, *numpy_fixes, # type: ignore[misc] FixNumpyDtype, FixNumpyArrayFlags, FixCurrentModulePrefixInTypeNames, FixBuiltinTypes, RewritePybind11EnumValueRepr, FilterClassMembers, ReplaceReadWritePropertyWithField, FilterInvalidIdentifiers, FixValueReprRandomAddress, FixRedundantBuiltinsAnnotation, FilterPybindInternals, FilterPybind11NativeEnumMembers, FilterPybind11ViewClasses, FixRedundantMethodsFromBuiltinObject, RemoveSelfAnnotation, FixPybind11EnumStrDoc, ExtractSignaturesFromPybind11Docstrings, ParserDispatchMixin, BaseParser, *error_handlers_bottom, # type: ignore[misc] ): pass parser = Parser() if args.enum_class_locations: parser.set_pybind11_enum_locations(dict(args.enum_class_locations)) if args.ignore_invalid_identifiers is not None: parser.set_ignored_invalid_identifiers(args.ignore_invalid_identifiers) if args.ignore_invalid_expressions is not None: parser.set_ignored_invalid_expressions(args.ignore_invalid_expressions) if args.ignore_unresolved_names is not None: parser.set_ignored_unresolved_names(args.ignore_unresolved_names) if args.print_safe_value_reprs is not None: parser.set_print_safe_value_pattern(args.print_safe_value_reprs) return parser def main(argv: Sequence[str] | None = None) -> None: logging.basicConfig( level=logging.INFO, format="%(name)s - [%(levelname)7s] %(message)s", ) args = arg_parser().parse_args(argv, namespace=CLIArgs()) parser = stub_parser_from_args(args) printer = Printer( invalid_expr_as_ellipses=not args.print_invalid_expressions_as_is, print_value_comments=args.print_value_comments, ) run( parser, printer, args.module_names, args.output_dir, root_suffix=args.root_suffix, dry_run=args.dry_run, writer=Writer(stub_ext=args.stub_extension), ) def to_output_and_subdir( output_dir: str, module_name: str, root_suffix: str | None ) -> tuple[Path, Path | None]: out_dir = Path(output_dir) module_path = module_name.split(".") if root_suffix is None: return out_dir.joinpath(*module_path[:-1]), None else: module_path = [f"{module_path[0]}{root_suffix}", *module_path[1:]] if len(module_path) == 1: sub_dir = Path(module_path[-1]) else: sub_dir = None return out_dir.joinpath(*module_path[:-1]), sub_dir def run( parser: IParser, printer: Printer, module_names: list[str], output_dir: str, root_suffix: str | None, dry_run: bool, writer: Writer, ): modules = [] for module_name in module_names: module = parser.handle_module( QualifiedName.from_str(module_name), importlib.import_module(module_name) ) if module is None: raise RuntimeError(f"Can't parse {module_name}") modules.append((module, module_name)) parser.finalize() if dry_run: return for module, module_name in modules: out_dir, sub_dir = to_output_and_subdir( output_dir=output_dir, module_name=module_name, root_suffix=root_suffix, ) out_dir.mkdir(exist_ok=True, parents=True) writer.write_module(module, printer, to=out_dir, sub_dir=sub_dir) if __name__ == "__main__": main() pybind-pybind11-stubgen-c8167c3/pybind11_stubgen/__main__.py000066400000000000000000000001021525537303700237040ustar00rootroot00000000000000from .__init__ import main if __name__ == "__main__": main() pybind-pybind11-stubgen-c8167c3/pybind11_stubgen/parser/000077500000000000000000000000001525537303700231155ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/pybind11_stubgen/parser/__init__.py000066400000000000000000000000001525537303700252140ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/pybind11_stubgen/parser/errors.py000066400000000000000000000015461525537303700250110ustar00rootroot00000000000000from __future__ import annotations from pybind11_stubgen.structs import Identifier, QualifiedName class ParserError(Exception): pass class InvalidIdentifierError(ParserError): def __init__(self, name: Identifier, found_at: QualifiedName): super().__init__() self.name = name self.at = found_at def __str__(self): return f"Invalid identifier '{self.name}' at '{self.at}'" class InvalidExpressionError(ParserError): def __init__(self, expression: str): super().__init__() self.expression: str = expression def __str__(self): return f"Invalid expression '{self.expression}'" class NameResolutionError(ParserError): def __init__(self, name: QualifiedName): super().__init__() self.name = name def __str__(self): return f"Can't find/import '{self.name}'" pybind-pybind11-stubgen-c8167c3/pybind11_stubgen/parser/interface.py000066400000000000000000000057411525537303700254360ustar00rootroot00000000000000from __future__ import annotations import abc import types from typing import Any, Callable, TypeVar from pybind11_stubgen.parser.errors import ParserError from pybind11_stubgen.structs import ( Alias, Argument, Attribute, Class, Docstring, Field, Function, Import, InvalidExpression, Method, Module, Property, QualifiedName, ResolvedType, Value, ) T = TypeVar("T") class IParser(abc.ABC): @abc.abstractmethod def handle_alias(self, path: QualifiedName, origin: Any) -> Alias | None: ... @abc.abstractmethod def handle_attribute(self, path: QualifiedName, attr: Any) -> Attribute | None: ... @abc.abstractmethod def handle_bases( self, path: QualifiedName, bases: tuple[type, ...] ) -> list[QualifiedName]: ... @abc.abstractmethod def handle_class(self, path: QualifiedName, class_: type) -> Class | None: ... @abc.abstractmethod def handle_class_member( self, path: QualifiedName, class_: type, obj: Any ) -> Docstring | Alias | Class | list[Method] | Field | Property | None: ... @abc.abstractmethod def handle_docstring(self, path: QualifiedName, doc: Any) -> Docstring | None: ... @abc.abstractmethod def handle_field(self, path: QualifiedName, field: Any) -> Field | None: ... @abc.abstractmethod def handle_function(self, path: QualifiedName, func: Any) -> list[Function]: ... @abc.abstractmethod def handle_import(self, path: QualifiedName, origin: Any) -> Import | None: ... @abc.abstractmethod def handle_method(self, path: QualifiedName, method: Any) -> list[Method]: ... @abc.abstractmethod def handle_module( self, path: QualifiedName, module: types.ModuleType ) -> Module | None: ... @abc.abstractmethod def handle_module_member( self, path: QualifiedName, module: types.ModuleType, obj: Any ) -> ( Docstring | Import | Alias | Class | list[Function] | Attribute | Module | None ): ... @abc.abstractmethod def handle_property(self, path: QualifiedName, prop: Any) -> Property | None: ... @abc.abstractmethod def handle_type(self, type_: type) -> QualifiedName: ... @abc.abstractmethod def handle_value(self, value: Any) -> Value: ... def call_with_local_types(self, parameters: list[str], func: Callable[[], T]) -> T: """ PEP 695 added template syntax to classes and functions. This will call the function with these additional local types. """ ... @abc.abstractmethod def parse_args_str(self, args_str: str) -> list[Argument]: ... @abc.abstractmethod def parse_annotation_str( self, annotation_str: str ) -> ResolvedType | InvalidExpression | Value: ... @abc.abstractmethod def parse_value_str(self, value: str) -> Value | InvalidExpression: ... @abc.abstractmethod def report_error(self, error: ParserError) -> None: ... @abc.abstractmethod def finalize(self): ... pybind-pybind11-stubgen-c8167c3/pybind11_stubgen/parser/mixins/000077500000000000000000000000001525537303700244245ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/pybind11_stubgen/parser/mixins/__init__.py000066400000000000000000000000001525537303700265230ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/pybind11_stubgen/parser/mixins/error_handlers.py000066400000000000000000000126501525537303700300130ustar00rootroot00000000000000from __future__ import annotations import re import sys import types from logging import getLogger from pybind11_stubgen.parser.errors import ( InvalidExpressionError, InvalidIdentifierError, NameResolutionError, ParserError, ) from pybind11_stubgen.parser.interface import IParser from pybind11_stubgen.structs import Class, Function, Method, Module, QualifiedName class LocalErrors: def __init__(self, path: QualifiedName, errors: set[str], stack: list[LocalErrors]): self.path: QualifiedName = path self.errors: set[str] = errors self._stack: list[LocalErrors] = stack def __enter__(self) -> LocalErrors: self._stack.append(self) return self def __exit__(self, exc_type, exc_val, exc_tb): top = self._stack.pop() assert top == self class LoggerData(IParser): def __init__(self): super().__init__() self.stack: list[LocalErrors] = [] def __new_layer(self, path: QualifiedName) -> LocalErrors: return LocalErrors(path, errors=set(), stack=self.stack) def handle_module( self, path: QualifiedName, module: types.ModuleType ) -> Module | None: with self.__new_layer(path): return super().handle_module(path, module) def handle_class(self, path: QualifiedName, class_: type) -> Class | None: with self.__new_layer(path): return super().handle_class(path, class_) def handle_function(self, path: QualifiedName, class_: type) -> list[Function]: with self.__new_layer(path): return super().handle_function(path, class_) def handle_method(self, path: QualifiedName, class_: type) -> list[Method]: with self.__new_layer(path): return super().handle_method(path, class_) @property def current_path(self) -> QualifiedName: assert len(self.stack) != 0 return self.stack[-1].path @property def reported_errors(self) -> set[str]: assert len(self.stack) != 0 return self.stack[-1].errors logger = getLogger("pybind11_stubgen") class LogErrors(IParser): def report_error(self: LoggerData, error: ParserError) -> None: error_str = f"In {self.current_path} : {error}" if error_str not in self.reported_errors: logger.error(error_str) self.reported_errors.add(error_str) super().report_error(error) class IgnoreUnresolvedNameErrors(IParser): def __init__(self): super().__init__() self.__regex: re.Pattern | None = None def set_ignored_unresolved_names(self, regex: re.Pattern): self.__regex = regex def report_error(self, error: ParserError): if self.__regex is not None: if isinstance(error, NameResolutionError): if self.__regex.match(str(error.name)): return super().report_error(error) class IgnoreInvalidExpressionErrors(IParser): def __init__(self): super().__init__() self.__regex: re.Pattern | None = None def set_ignored_invalid_expressions(self, regex: re.Pattern): self.__regex = regex def report_error(self, error: ParserError): if self.__regex is not None: if isinstance(error, InvalidExpressionError): if self.__regex.match(error.expression): return super().report_error(error) class IgnoreInvalidIdentifierErrors(IParser): def __init__(self): super().__init__() self.__regex: re.Pattern | None = None def set_ignored_invalid_identifiers(self, regex: re.Pattern): self.__regex = regex def report_error(self, error: ParserError): if self.__regex is not None: if isinstance(error, InvalidIdentifierError): if self.__regex.match(str(error.name)): return super().report_error(error) class IgnoreAllErrors(IParser): def report_error(self, error: ParserError): return None class SuggestCxxSignatureFix(IParser): def __init__(self): super().__init__() self.suggest_cxx_fix = False def report_error(self, error: ParserError): if isinstance(error, InvalidExpressionError): expression = error.expression if "::" in expression or expression.endswith(">"): self.suggest_cxx_fix = True super().report_error(error) def finalize(self): if self.suggest_cxx_fix: logger.warning( "Raw C++ types/values were found in signatures extracted " "from docstrings.\n" "Please check the corresponding sections of pybind11 documentation " "to avoid common mistakes in binding code:\n" " - https://pybind11.readthedocs.io/en/latest/advanced/misc.html" "#avoiding-cpp-types-in-docstrings\n" " - https://pybind11.readthedocs.io/en/latest/advanced/functions.html" "#default-arguments-revisited" ) super().finalize() class TerminateOnFatalErrors(IParser): def __init__(self): super().__init__() self.__found_fatal_errors = False def report_error(self, error: ParserError): self.__found_fatal_errors = True super().report_error(error) def finalize(self): super().finalize() if self.__found_fatal_errors: logger.info("Terminating due to previous errors") sys.exit(1) pybind-pybind11-stubgen-c8167c3/pybind11_stubgen/parser/mixins/filter.py000066400000000000000000000136641525537303700262750ustar00rootroot00000000000000from __future__ import annotations import types import typing from typing import Any from pybind11_stubgen.parser.errors import InvalidIdentifierError from pybind11_stubgen.parser.interface import IParser from pybind11_stubgen.structs import ( Alias, Attribute, Class, Docstring, Field, Function, Identifier, Import, Method, Module, Property, QualifiedName, ) class FilterTypingModuleAttributes(IParser): __sentinel = object() def handle_attribute(self, path: QualifiedName, attr: Any) -> Attribute | None: if getattr(typing, str(path[-1]), self.__sentinel) is attr: return None return super().handle_attribute(path, attr) class FilterClassMembers(IParser): __attribute_blacklist: set[Identifier] = { *map( Identifier, ( "__annotations__", "__builtins__", "__cached__", "__file__", "__firstlineno__", "__loader__", "__name__", "__package__", "__path__", "__spec__", "__static_attributes__", ), ) } __class_member_blacklist: set[Identifier] = { *map( Identifier, ( "__annotations__", "__class__", "__dict__", "__module__", "__qualname__", "__weakref__", ), ) } __method_blacklist: set[Identifier] = {*map(Identifier, ("__dir__", "__sizeof__"))} def handle_class_member( self, path: QualifiedName, class_: type, member: Any ) -> Docstring | Alias | Class | list[Method] | Field | Property | None: name = path[-1] if name in self.__class_member_blacklist: return None if not hasattr(class_, "__dict__") or name not in class_.__dict__: # Skip members inherited from base classes return None return super().handle_class_member(path, class_, member) def handle_method(self, path: QualifiedName, value: Any) -> list[Method]: if path[-1] in self.__method_blacklist: return [] return super().handle_method(path, value) def handle_attribute(self, path: QualifiedName, attr: Any) -> Attribute | None: if path[-1] in self.__attribute_blacklist: return None return super().handle_attribute(path, attr) class FilterPybindInternals(IParser): __attribute_blacklist: set[Identifier] = {*map(Identifier, ("__entries",))} __class_blacklist: set[Identifier] = {*map(Identifier, ("pybind11_type",))} def handle_attribute(self, path: QualifiedName, value: Any) -> Attribute | None: if path[-1] in self.__attribute_blacklist: return None return super().handle_attribute(path, value) def handle_class_member( self, path: QualifiedName, class_: type, member: Any ) -> Docstring | Alias | Class | list[Method] | Field | Property | None: name = path[-1] if name in self.__class_blacklist: return None if name.startswith("__pybind11_module"): return None if name.startswith("_pybind11_conduit_v1_"): return None return super().handle_class_member(path, class_, member) class FilterInvalidIdentifiers(IParser): def handle_module_member( self, path: QualifiedName, module: types.ModuleType, obj: Any ) -> ( Docstring | Import | Alias | Class | list[Function] | Attribute | Module | None ): if not path[-1].isidentifier(): self.report_error(InvalidIdentifierError(path[-1], path.parent)) return None return super().handle_module_member(path, module, obj) def handle_class_member( self, path: QualifiedName, class_: type, obj: Any ) -> Docstring | Alias | Class | list[Method] | Field | Property | None: if not path[-1].isidentifier(): self.report_error(InvalidIdentifierError(path[-1], path.parent)) return None return super().handle_class_member(path, class_, obj) class FilterPybind11ViewClasses(IParser): def handle_module_member( self, path: QualifiedName, module: types.ModuleType, obj: Any ) -> ( Docstring | Import | Alias | Class | list[Function] | Attribute | Module | None ): result = super().handle_module_member(path, module, obj) if isinstance(result, Class) and str(result.name) in [ "ItemsView", "KeysView", "ValuesView", ]: # TODO: check obj is a subclass of pybind11_object return None return result class FilterPybind11NativeEnumMembers(IParser): @staticmethod def _is_sunder(name: str) -> bool: """Match CPython Enum's reserved ``_sunder_`` names. Keep this in sync with CPython's ``enum._is_sunder``: https://github.com/python/cpython/blob/3.14/Lib/enum.py#L57-L66 These names are rejected by ``EnumDict.__setitem__`` unless explicitly allowlisted by ``enum`` itself: https://github.com/python/cpython/blob/3.14/Lib/enum.py#L342-L367 """ return ( len(name) > 2 and name[0] == name[-1] == "_" and name[1] != "_" and name[-2] != "_" ) def handle_class_member( self, path: QualifiedName, class_: type, obj: Any ) -> Docstring | Alias | Class | list[Method] | Field | Property | None: name = str(path[-1]) # py::native_enum exposes Enum internals via __dict__, but emitting them # into a stub that later gets executed as Python can fail at import time. if hasattr(class_, "__pybind11_native_enum__") and ( name == "__pybind11_native_enum__" or self._is_sunder(name) ): return None return super().handle_class_member(path, class_, obj) pybind-pybind11-stubgen-c8167c3/pybind11_stubgen/parser/mixins/fix.py000066400000000000000000001210041525537303700255620ustar00rootroot00000000000000from __future__ import annotations import builtins import importlib import inspect import re import types from logging import getLogger from typing import Any, Callable, Sequence, TypeVar from pybind11_stubgen.parser.errors import ( InvalidExpressionError, NameResolutionError, ParserError, ) from pybind11_stubgen.parser.interface import IParser from pybind11_stubgen.structs import ( Alias, Argument, Attribute, Class, Docstring, Field, Function, Identifier, Import, InvalidExpression, Method, Module, Property, QualifiedName, ResolvedType, TypeVar_, Value, ) from pybind11_stubgen.typing_ext import DynamicSize, FixedSize logger = getLogger("pybind11_stubgen") T = TypeVar("T") class RemoveSelfAnnotation(IParser): __any_t_name = QualifiedName.from_str("Any") __typing_any_t_name = QualifiedName.from_str("typing.Any") def handle_method(self, path: QualifiedName, method: Any) -> list[Method]: methods = super().handle_method(path, method) for method in methods: self._remove_self_arg_annotation(path, method.function) return methods def handle_property(self, path: QualifiedName, prop: Any) -> Property | None: prop = super().handle_property(path, prop) if prop is not None: if prop.getter is not None: self._remove_self_arg_annotation(path, prop.getter) if prop.setter is not None: self._remove_self_arg_annotation(path, prop.setter) return prop def _remove_self_arg_annotation(self, path: QualifiedName, func: Function) -> None: if len(func.args) == 0: return fully_qualified_class_name = QualifiedName(path[:-1]) # remove the method name first_arg = func.args[0] if ( first_arg.name == "self" and isinstance(first_arg.annotation, ResolvedType) and not first_arg.annotation.parameters and ( first_arg.annotation.name in { self.__any_t_name, self.__typing_any_t_name, fully_qualified_class_name, fully_qualified_class_name[-len(first_arg.annotation.name) :], } ) ): first_arg.annotation = None class FixMissingImports(IParser): def __init__(self): super().__init__() self.__extra_imports: set[Import] = set() self.__current_module: types.ModuleType | None = None self.__current_class: type | None = None self.__local_types: set[str] = set() def handle_alias(self, path: QualifiedName, origin: Any) -> Alias | None: result = super().handle_alias(path, origin) if result is None: return None self._add_import(result.origin) return result def handle_attribute(self, path: QualifiedName, attr: Any) -> Attribute | None: result = super().handle_attribute(path, attr) if result is None: return None if isinstance(result.annotation, ResolvedType): self._add_import(result.annotation.name) return result def handle_class(self, path: QualifiedName, class_: type) -> Class | None: old_class = self.__current_class self.__current_class = class_ result = super().handle_class(path, class_) self.__current_class = old_class return result def handle_import(self, path: QualifiedName, origin: Any) -> Import | None: result = super().handle_import(path, origin) if result is None: return None self.__extra_imports.add(result) return result def handle_module( self, path: QualifiedName, module: types.ModuleType ) -> Module | None: old_imports = self.__extra_imports old_module = self.__current_module self.__extra_imports = set() self.__current_module = module result = super().handle_module(path, module) if result is not None: result.imports |= self.__extra_imports self.__extra_imports = old_imports self.__current_module = old_module return result def handle_type(self, type_: type) -> QualifiedName: result = super().handle_type(type_) if not inspect.ismodule(type_): self._add_import(result) return result def handle_value(self, value: Any) -> Value: result = super().handle_value(value) if inspect.isroutine(value) and result.is_print_safe: self._add_import(QualifiedName.from_str(result.repr)) return result def call_with_local_types(self, parameters: list[str], func: Callable[[], T]) -> T: original_local_types = self.__local_types.copy() self.__local_types.update(parameters) result = super().call_with_local_types(parameters, func) self.__local_types = original_local_types return result def parse_annotation_str( self, annotation_str: str ) -> ResolvedType | InvalidExpression | Value: result = super().parse_annotation_str(annotation_str) if isinstance(result, ResolvedType): self._add_import(result.name) return result def _add_import(self, name: QualifiedName) -> None: if len(name) == 0: return if len(name) == 1 and (len(name[0]) == 0 or name[0] in self.__local_types): return if hasattr(builtins, name[0]): return if self.__current_class is not None and hasattr(self.__current_class, name[0]): return if self.__current_module is not None and hasattr( self.__current_module, name[0] ): return module_name = self._get_parent_module(name) if module_name is None: self.report_error(NameResolutionError(name)) return self.__extra_imports.add(Import(name=None, origin=module_name)) def _get_parent_module(self, name: QualifiedName) -> QualifiedName | None: parent = name.parent while len(parent) != 0: if self._is_module(parent): if not self._is_accessible(name, from_module=parent): return None return parent parent = parent.parent return None def _is_module(self, name: QualifiedName): try: return importlib.import_module(str(name)) is not None except ModuleNotFoundError: return False def _is_accessible(self, name: QualifiedName, from_module: QualifiedName) -> bool: try: parent = importlib.import_module(str(from_module)) except ModuleNotFoundError: return False relative_path = name[len(from_module) :] for part in relative_path: if not hasattr(parent, part): return False parent = getattr(parent, part) return True class FixMissing__future__AnnotationsImport(IParser): def handle_module( self, path: QualifiedName, module: types.ModuleType ) -> Module | None: result = super().handle_module(path, module) if result is None: return None result.imports.add(self._future(Identifier("annotations"))) return result def _future(self, feature: Identifier) -> Import: return Import( name=feature, origin=QualifiedName((Identifier("__future__"), feature)) ) class FixMissing__all__Attribute(IParser): def handle_module( self, path: QualifiedName, module: types.ModuleType ) -> Module | None: result = super().handle_module(path, module) if result is None: return None # don't override __all__ for attr in result.attributes: if attr.name == Identifier("__all__"): return result all_names: list[str] = sorted( set( filter( lambda name: not name.startswith("_"), map( str, ( *(class_.name for class_ in result.classes), *(attr.name for attr in result.attributes), *(func.name for func in result.functions), *(alias.name for alias in result.aliases), *( import_.name for import_ in result.imports if import_.name is not None ), *(sub_module.name for sub_module in result.sub_modules), ), ), ) ) ) result.attributes.append( Attribute( name=Identifier("__all__"), value=self.handle_value(all_names), annotation=ResolvedType(name=QualifiedName.from_str("list[str]")), ) ) return result class FixBuiltinTypes(IParser): _any_type = QualifiedName.from_str("typing.Any") _hidden_builtins = { getattr(types, name).__qualname__: name for name in dir(types) if isinstance(getattr(types, name), type) and getattr(getattr(types, name), "__module__", None) == "builtins" # defined in types, but reports `builtins` and not hasattr(builtins, name) # not actually available in `builtins` } """Types by their real name that are available in the `types` module, but report `builtins` at runtime.""" _hidden_builtins_overrides = { "function": "typing.Callable", "builtin_function_or_method": "typing.Callable", } """Manual overrides for builtin types.""" def handle_type(self, type_: type) -> QualifiedName: if type_.__qualname__ == "PyCapsule" and type_.__module__ == "builtins": return self._any_type result = super().handle_type(type_) if result[0] == "builtins": typename = result[1] if typename == "NoneType": return QualifiedName( (Identifier("None"),) ) # just print None instead of types.NoneType # some types (e.g. `types.MappingProxyType`) report a wrong qualname # at runtime, and module == `builtins` # we collect these upfront and translate their "builtin" name to the # importable one hidden_builtin = self._hidden_builtins.get(typename) if hidden_builtin is not None: # some of these types are better described via the `typing` # special forms e.g. types.FunctionType -> typing.Callable, # so we use the override name hidden_builtin_override = self._hidden_builtins_overrides.get(typename) annotation = hidden_builtin_override or "types.%s" % hidden_builtin override_t = self.parse_annotation_str(annotation) if not isinstance(override_t, ResolvedType): raise TypeError( f"Expected ResolvedType for {annotation!r}, " f"got {type(override_t).__name__}" ) return override_t.name return QualifiedName(result[1:]) return result def report_error(self, error: ParserError): if isinstance(error, NameResolutionError): if error.name[0] in ["PyCapsule"]: return super().report_error(error) class FixRedundantBuiltinsAnnotation(IParser): def handle_attribute(self, path: QualifiedName, attr: Any) -> Attribute | None: result = super().handle_attribute(path, attr) if result is None: return None if attr is None or inspect.ismodule(attr): result.annotation = None return result class FixMissingNoneHashFieldAnnotation(IParser): def handle_field(self, path: QualifiedName, field: Any) -> Field | None: result = super().handle_field(path, field) if result is None: return None if field is None and path[-1] == "__hash__": result.attribute.annotation = self.parse_annotation_str( "typing.ClassVar[None]" ) return result class FixPEP585CollectionNames(IParser): __typing_collection_names: set[Identifier] = set( Identifier(name) for name in ( "Dict", "List", "Set", "Tuple", "FrozenSet", "Type", ) ) def parse_annotation_str( self, annotation_str: str ) -> ResolvedType | InvalidExpression | Value: result = super().parse_annotation_str(annotation_str) if ( not isinstance(result, ResolvedType) or len(result.name) != 2 or result.name[0] != "typing" ): return result word = result.name[1] if word in self.__typing_collection_names: result.name = QualifiedName.from_str(f"{word.lower()}") return result class FixTypingTypeNames(IParser): __typing_names: set[Identifier] = set( Identifier(name) for name in ( "Annotated", "Any", "Buffer", "Callable", "Dict", "ItemsView", "Iterable", "Iterator", "KeysView", "List", "Literal", "Optional", "Sequence", "Set", "Tuple", "Union", "ValuesView", # Old pybind11 annotations were not capitalized "buffer", "iterable", "iterator", "sequence", ) ) __typing_extensions_names: set[Identifier] = set( Identifier(name) for name in ( "buffer", "Buffer", ) ) def parse_annotation_str( self, annotation_str: str ) -> ResolvedType | InvalidExpression | Value: result = super().parse_annotation_str(annotation_str) return self._parse_annotation_str(result) def _parse_annotation_str( self, result: ResolvedType | InvalidExpression | Value ) -> ResolvedType | InvalidExpression | Value: if not isinstance(result, ResolvedType): return result result.parameters = ( [self._parse_annotation_str(p) for p in result.parameters] if result.parameters is not None else None ) if len(result.name) != 1: return result word = result.name[0] if word in self.__typing_names: package = "typing" if word in self.__typing_extensions_names: package = "typing_extensions" result.name = QualifiedName.from_str( f"{package}.{word[0].upper()}{word[1:]}" ) if word == "function" and result.parameters is None: result.name = QualifiedName.from_str("typing.Callable") if word in ("object", "handle") and result.parameters is None: result.name = QualifiedName.from_str("typing.Any") return result class FixCurrentModulePrefixInTypeNames(IParser): def __init__(self): super().__init__() self.__current_module: QualifiedName = QualifiedName() def handle_alias(self, path: QualifiedName, origin: Any) -> Alias | None: result = super().handle_alias(path, origin) if result is None: return None result.origin = self._strip_current_module(result.origin) return result def handle_attribute(self, path: QualifiedName, attr: Any) -> Attribute | None: result = super().handle_attribute(path, attr) if result is None: return None if result.annotation is not None: result.annotation = self._strip_current_module_prefix(result.annotation) return result def handle_module( self, path: QualifiedName, module: types.ModuleType ) -> Module | None: tmp = self.__current_module self.__current_module = path result = super().handle_module(path, module) self.__current_module = tmp return result def handle_type(self, type_: type) -> QualifiedName: result = super().handle_type(type_) return self._strip_current_module(result) def handle_value(self, value: Any) -> Value: result = super().handle_value(value) if inspect.isroutine(value): result.repr = str( self._strip_current_module(QualifiedName.from_str(result.repr)) ) return result def parse_annotation_str( self, annotation_str: str ) -> ResolvedType | InvalidExpression | Value: result = super().parse_annotation_str(annotation_str) return self._strip_current_module_prefix(result) def _strip_current_module_prefix( self, annotation: ResolvedType | InvalidExpression | Value ) -> ResolvedType | InvalidExpression | Value: """ Strip the current module prefix from all resolved type names in an annotation tree. Python may evaluate local annotations such as ``list[Token]`` into runtime generics like ``list[mymodule.MyClass.Token]``. The outer container type (``list`` / ``typing.Optional`` / ``dict``) is valid, but nested parameters that point back into the current module should be rendered as local names in the generated stub. """ if not isinstance(annotation, ResolvedType): return annotation annotation.name = self._strip_current_module(annotation.name) if annotation.parameters is not None: annotation.parameters = [ self._strip_current_module_prefix(parameter) for parameter in annotation.parameters ] return annotation def _strip_current_module(self, name: QualifiedName) -> QualifiedName: if name[: len(self.__current_module)] == self.__current_module: return QualifiedName(name[len(self.__current_module) :]) return name class FixValueReprRandomAddress(IParser): """ repr examples: # PyCapsule # no "object" keyword """ _pattern = re.compile( r"<(?P[\w.]+(?:\s+object)?)" r"(?:\s+\w+)*" r"\s+at\s+" r"0x[a-fA-F0-9]+>" ) def handle_value(self, value: Any) -> Value: result = super().handle_value(value) result.repr = self._pattern.sub(r"<\g>", result.repr) return result class FixNumpyArrayDimAnnotation(IParser): __array_names: set[QualifiedName] = { QualifiedName.from_str("numpy.ndarray"), *( QualifiedName.from_str(f"scipy.sparse.{storage}_{arr}") for storage in ["bsr", "coo", "csr", "csc", "dia", "dok", "lil"] for arr in ["array", "matrix"] ), } # NB: Not using full name due to ambiguity `typing.Annotated` vs # `typing_extension.Annotated` in different python versions # Rely on later fix by `FixTypingTypeNames` __annotated_name = QualifiedName.from_str("Annotated") numpy_primitive_types: set[QualifiedName] = set( map( QualifiedName.from_str, ( "bool", *map( lambda name: f"numpy.{name}", ( "uint8", "int8", "uint16", "int16", "uint32", "int32", "uint64", "int64", "float16", "float32", "float64", "complex32", "complex64", "longcomplex", ), ), ), ) ) __DIM_VARS = ["n", "m"] def parse_annotation_str( self, annotation_str: str ) -> ResolvedType | InvalidExpression | Value: # Affects types of the following pattern: # ARRAY_T[PRIMITIVE_TYPE[*DIMS], *FLAGS] # Replace with: # Annotated[ARRAY_T, PRIMITIVE_TYPE, FixedSize/DynamicSize[*DIMS], *FLAGS] result = super().parse_annotation_str(annotation_str) if ( not isinstance(result, ResolvedType) or result.name not in self.__array_names or result.parameters is None or len(result.parameters) == 0 ): return result scalar_with_dims = result.parameters[0] # e.g. numpy.float64[32, 32] flags = result.parameters[1:] if ( not isinstance(scalar_with_dims, ResolvedType) or scalar_with_dims.name not in self.numpy_primitive_types ): return result result = ResolvedType( name=self.__annotated_name, parameters=[ self.parse_annotation_str(str(result.name)), ResolvedType(scalar_with_dims.name), ], ) assert result.parameters is not None if ( scalar_with_dims.parameters is not None and len(scalar_with_dims.parameters) >= 0 ): dims = self.__to_dims(scalar_with_dims.parameters) if dims is not None and len(dims) > 0: result.parameters += [ self.handle_value(self.__wrap_with_size_helper(dims)) ] result.parameters += flags return result def __wrap_with_size_helper(self, dims: list[int | str]) -> FixedSize | DynamicSize: if all(isinstance(d, int) for d in dims): return_t = FixedSize else: return_t = DynamicSize # TRICK: Use `self.handle_type` to make `FixedSize`/`DynamicSize` # properly added to the list of imports self.handle_type(return_t) return return_t(*dims) # type: ignore[arg-type] def __to_dims( self, dimensions: Sequence[ResolvedType | Value | InvalidExpression] ) -> list[int | str] | None: result = [] for dim_param in dimensions: if isinstance(dim_param, Value): try: dim = int(dim_param.repr) except ValueError: return None elif isinstance(dim_param, ResolvedType): dim = str(dim_param) if dim not in self.__DIM_VARS: return None else: return None result.append(dim) return result def report_error(self, error: ParserError) -> None: if ( isinstance(error, NameResolutionError) and len(error.name) == 1 and len(error.name[0]) == 1 and error.name[0] in self.__DIM_VARS ): # Ignores all unknown 'm' and 'n' regardless of the context return super().report_error(error) class FixNumpyArrayDimTypeVar(IParser): __array_names: set[QualifiedName] = {QualifiedName.from_str("numpy.ndarray")} numpy_primitive_types = FixNumpyArrayDimAnnotation.numpy_primitive_types __DIM_VARS: set[str] = set() __local_types: set[str] = set() def handle_module( self, path: QualifiedName, module: types.ModuleType ) -> Module | None: result = super().handle_module(path, module) if result is None: return None if self.__DIM_VARS: # the TypeVar_'s generated code will reference `typing` result.imports.add( Import(name=None, origin=QualifiedName.from_str("typing")) ) for name in self.__DIM_VARS: result.type_vars.append( TypeVar_( name=Identifier(name), bound=self.parse_annotation_str("int"), ), ) self.__DIM_VARS.clear() return result def call_with_local_types(self, parameters: list[str], func: Callable[[], T]) -> T: original_local_types = self.__local_types.copy() self.__local_types.update(parameters) result = super().call_with_local_types(parameters, func) self.__local_types = original_local_types return result def parse_annotation_str( self, annotation_str: str ) -> ResolvedType | InvalidExpression | Value: # Affects types of the following pattern: # numpy.ndarray[PRIMITIVE_TYPE[*DIMS], *FLAGS] # Replace with: # numpy.ndarray[tuple[M, Literal[1]], numpy.dtype[numpy.float32]] result = super().parse_annotation_str(annotation_str) if not isinstance(result, ResolvedType): return result if len(result.name) == 1 and result.name[0] in self.__local_types: return result # handle unqualified, single-letter annotation as a TypeVar if len(result.name) == 1 and len(result.name[0]) == 1: result.name = QualifiedName.from_str(result.name[0].upper()) self.__DIM_VARS.add(result.name[0]) if result.name not in self.__array_names: return result # ndarray is generic and should have 2 type arguments if result.parameters is None or len(result.parameters) == 0: result.parameters = [ self.parse_annotation_str("Any"), ResolvedType( name=QualifiedName.from_str("numpy.dtype"), parameters=[self.parse_annotation_str("Any")], ), ] return result scalar_with_dims = result.parameters[0] # e.g. numpy.float64[32, 32] if ( not isinstance(scalar_with_dims, ResolvedType) or scalar_with_dims.name not in self.numpy_primitive_types ): return result name = scalar_with_dims.name # Pybind annotates a bool Python type, which cannot be used with # numpy.dtype because it does not inherit from numpy.generic. # Only numpy.bool_ works reliably with both NumPy 1.x and 2.x. if str(name) == "bool": name = QualifiedName.from_str("numpy.bool_") dtype = ResolvedType( name=QualifiedName.from_str("numpy.dtype"), parameters=[ResolvedType(name=name)], ) shape = self.parse_annotation_str("Any") if ( scalar_with_dims.parameters is not None and len(scalar_with_dims.parameters) > 0 ): dims = self.__to_dims(scalar_with_dims.parameters) if dims is not None: shape = self.parse_annotation_str("Tuple") assert isinstance(shape, ResolvedType) shape.parameters = [] for dim in dims: if isinstance(dim, int): # self.parse_annotation_str will qualify Literal with either # typing or typing_extensions and add the import to the module literal_dim = self.parse_annotation_str("Literal") assert isinstance(literal_dim, ResolvedType) literal_dim.parameters = [Value(repr=str(dim))] shape.parameters.append(literal_dim) else: shape.parameters.append( ResolvedType(name=QualifiedName.from_str(dim)) ) result.parameters = [shape, dtype] return result def __to_dims( self, dimensions: Sequence[ResolvedType | Value | InvalidExpression] ) -> list[int | str] | None: result: list[int | str] = [] for dim_param in dimensions: if isinstance(dim_param, Value): try: dim = int(dim_param.repr) except ValueError: return None elif isinstance(dim_param, ResolvedType): dim = str(dim_param) else: return None result.append(dim) return result def report_error(self, error: ParserError) -> None: if ( isinstance(error, NameResolutionError) and len(error.name) == 1 and error.name[0] in self.__DIM_VARS ): # allow type variables, which are manually resolved in `handle_module` return super().report_error(error) class FixNumpyArrayRemoveParameters(IParser): __ndarray_name = QualifiedName.from_str("numpy.ndarray") def parse_annotation_str( self, annotation_str: str ) -> ResolvedType | InvalidExpression | Value: result = super().parse_annotation_str(annotation_str) if isinstance(result, ResolvedType) and result.name == self.__ndarray_name: result.parameters = None return result class FixScipyTypeArguments(IParser): def parse_annotation_str( self, annotation_str: str ) -> ResolvedType | InvalidExpression | Value: result = super().parse_annotation_str(annotation_str) if not isinstance(result, ResolvedType): return result # scipy.sparse arrays/matrices are not currently generic and do not accept type # arguments if result.name[:2] == ("scipy", "sparse"): result.parameters = None return result class FixNumpyDtype(IParser): __numpy_dtype = QualifiedName.from_str("numpy.dtype") def parse_annotation_str( self, annotation_str: str ) -> ResolvedType | InvalidExpression | Value: result = super().parse_annotation_str(annotation_str) if not isinstance(result, ResolvedType) or result.parameters: return result # numpy.dtype is generic and should have a type argument if result.name[:1] == ("dtype",) or result.name[:2] == ("numpy", "dtype"): result.name = self.__numpy_dtype result.parameters = [self.parse_annotation_str("Any")] return result class FixNumpyArrayFlags(IParser): __ndarray_name = QualifiedName.from_str("numpy.ndarray") __flags: set[QualifiedName] = { QualifiedName.from_str("flags.writeable"), QualifiedName.from_str("flags.c_contiguous"), QualifiedName.from_str("flags.f_contiguous"), } def parse_annotation_str( self, annotation_str: str ) -> ResolvedType | InvalidExpression | Value: result = super().parse_annotation_str(annotation_str) if isinstance(result, ResolvedType) and result.name == self.__ndarray_name: if result.parameters is not None: for param in result.parameters: if isinstance(param, ResolvedType) and param.name in self.__flags: param.name = QualifiedName.from_str( f"numpy.ndarray.{param.name}" ) return result def report_error(self, error: ParserError) -> None: if isinstance(error, NameResolutionError) and error.name in self.__flags: return super().report_error(error) class FixRedundantMethodsFromBuiltinObject(IParser): def handle_method(self, path: QualifiedName, method: Any) -> list[Method]: result = super().handle_method(path, method) return [ m for m in result if not ( m.function.name == "__init__" and m.function.doc == object.__init__.__doc__ ) ] class ReplaceReadWritePropertyWithField(IParser): def handle_class_member( self, path: QualifiedName, class_: type, obj: Any ) -> Docstring | Alias | Class | list[Method] | Field | Property | None: result = super().handle_class_member(path, class_, obj) if isinstance(result, Property): if ( result.doc is None and result.getter is not None and result.setter is not None and len(result.getter.args) == 1 and len(result.setter.args) == 2 and result.getter.doc is None and result.setter.doc is None and result.getter.returns == result.setter.args[1].annotation ): return Field( attribute=Attribute( name=result.name, annotation=result.getter.returns, value=None ), modifier=None, ) return result class FixMissingFieldDocString(IParser): """Extracts docstrings for `def_property_readonly_static` and `def_property_static`.""" def handle_class_member( self, path: QualifiedName, class_: type, obj: Any ) -> Docstring | Alias | Class | list[Method] | Field | Property | None: result = super().handle_class_member(path, class_, obj) # `ParserDispatchMixin.handle_class_member` classifies static properties as `Field` instead of `Property`. if isinstance(result, Field): obj2 = class_.__dict__[path[-1]] doc = getattr(obj2, "__doc__", None) # If the current item is a static property, `obj` contains the fully resolved value, # but `obj2` contains a `pybind11_builtins.pybind11_static_property` proxy object. # In Python 3.12+, this proxy object has a `__doc__` attribute. if obj is not obj2 and isinstance(doc, str): result.attribute.doc = Docstring(doc) return result class FixMissingFixedSizeImport(IParser): def parse_annotation_str( self, annotation_str: str ) -> ResolvedType | InvalidExpression | Value: # Accommodate to # https://github.com/pybind/pybind11/pull/4679 result = super().parse_annotation_str(annotation_str) if ( isinstance(result, Value) and result.repr.startswith("FixedSize(") and result.repr.endswith(")") ): try: dimensions = map( int, result.repr[len("FixedSize(") : -len(")")].split(","), ) except ValueError: pass else: # call `handle_type` to trigger implicit import self.handle_type(FixedSize) return self.handle_value(FixedSize(*dimensions)) return result class FixMissingEnumMembersAnnotation(IParser): __class_var_dict = ResolvedType( name=QualifiedName.from_str("typing.ClassVar"), parameters=[ResolvedType(name=QualifiedName.from_str("dict"))], ) def handle_field(self, path: QualifiedName, field: Any) -> Field | None: result = super().handle_field(path, field) if result is None: return None if ( path[-1] == "__members__" and isinstance(field, dict) and result.attribute.annotation == self.__class_var_dict ): assert isinstance(result.attribute.annotation, ResolvedType) dict_type = self._guess_dict_type(field) if dict_type is not None: result.attribute.annotation.parameters = [dict_type] return result def _guess_dict_type(self, d: dict) -> ResolvedType | None: if len(d) == 0: return None key_types = set() value_types = set() for key, value in d.items(): key_types.add(self.handle_type(type(key))) value_types.add(self.handle_type(type(value))) if len(key_types) == 1: key_type = [ResolvedType(name=t) for t in key_types][0] else: union_t = self.parse_annotation_str("typing.Union") assert isinstance(union_t, ResolvedType) key_type = ResolvedType( name=union_t.name, parameters=[ResolvedType(name=t) for t in key_types] ) if len(value_types) == 1: value_type = [ResolvedType(name=t) for t in value_types][0] else: union_t = self.parse_annotation_str("typing.Union") assert isinstance(union_t, ResolvedType) value_type = ResolvedType( name=union_t.name, parameters=[ResolvedType(name=t) for t in value_types], ) dict_t = self.parse_annotation_str("typing.Dict") assert isinstance(dict_t, ResolvedType) return ResolvedType( name=dict_t.name, parameters=[key_type, value_type], ) class FixPybind11EnumStrDoc(IParser): def handle_class_member( self, path: QualifiedName, class_: type, obj: Any ) -> Docstring | Alias | Class | list[Method] | Field | Property | None: result = super().handle_class_member(path, class_, obj) if not isinstance(result, list) or not hasattr( # list[Method] class_, "__members__" ): # class is enum return result for method in result: assert isinstance(method, Method) if ( method.function.name != "__str__" or method.function.doc != "name(self: handle) -> str\n" ): continue method.function.args = [ Argument( name=Identifier("self"), # annotation=ResolvedType(self.handle_type(class_)), ) ] method.function.returns = ResolvedType(name=QualifiedName.from_str("str")) # Note: Wrong function name in __str.__.__doc__ triggered # generic (*args, **kwargs) signature which in turn # recognized as a static method signature method.modifier = None method.function.doc = None return result class OverridePrintSafeValues(IParser): _print_safe_values: re.Pattern | None def __init__(self): super().__init__() self._print_safe_values = None def set_print_safe_value_pattern(self, pattern: re.Pattern): self._print_safe_values = pattern def parse_value_str(self, value: str) -> Value | InvalidExpression: result = super().parse_value_str(value) if ( self._print_safe_values is not None and isinstance(result, Value) and not result.is_print_safe and self._print_safe_values.match(result.repr) is not None ): result.is_print_safe = True return result class RewritePybind11EnumValueRepr(IParser): _pybind11_enum_pattern = re.compile(r"<(?P\w+(\.\w+)+): (?P-?\d+)>") # _pybind11_enum_pattern = re.compile(r"<(?P\w+(\.\w+)+): (?P\d+)>") _unknown_enum_classes: set[str] = set() def __init__(self): super().__init__() self._pybind11_enum_locations: dict[re.Pattern, str] = {} def set_pybind11_enum_locations(self, locations: dict[re.Pattern, str]): self._pybind11_enum_locations = locations def parse_value_str(self, value: str) -> Value | InvalidExpression: value = value.strip() match = self._pybind11_enum_pattern.match(value) if match is not None: enum_qual_name = match.group("enum") enum_class_str, entry = enum_qual_name.rsplit(".", maxsplit=1) for pattern, prefix in self._pybind11_enum_locations.items(): if pattern.match(enum_class_str) is None: continue enum_class = self.parse_annotation_str(f"{prefix}.{enum_class_str}") if isinstance(enum_class, ResolvedType): return Value(repr=f"{enum_class.name}.{entry}", is_print_safe=True) return super().parse_value_str(value) def report_error(self, error: ParserError) -> None: if isinstance(error, InvalidExpressionError): match = self._pybind11_enum_pattern.match(error.expression) if match is not None: enum_qual_name = match.group("enum") enum_class_str, entry = enum_qual_name.rsplit(".", maxsplit=1) self._unknown_enum_classes.add(enum_class_str) super().report_error(error) def finalize(self): if self._unknown_enum_classes: logger.warning( "Enum-like str representations were found with no " "matching mapping to the enum class location.\n" "Use `--enum-class-locations` to specify " "full path to the following enum(s):\n" + "\n".join(f" - {c}" for c in self._unknown_enum_classes) ) super().finalize() pybind-pybind11-stubgen-c8167c3/pybind11_stubgen/parser/mixins/parse.py000066400000000000000000001022741525537303700261160ustar00rootroot00000000000000from __future__ import annotations import ast import inspect import re import sys import types import typing from typing import Any, Callable, TypeVar from pybind11_stubgen.parser.errors import ( InvalidExpressionError, InvalidIdentifierError, NameResolutionError, ParserError, ) from pybind11_stubgen.parser.interface import IParser from pybind11_stubgen.structs import ( Alias, Argument, Attribute, Class, Decorator, Docstring, Field, Function, Identifier, Import, InvalidExpression, Method, Modifier, Module, Property, QualifiedName, ResolvedType, TypeVar_, Value, ) _generic_args = [ Argument(name=Identifier("args"), variadic=True), Argument(name=Identifier("kwargs"), kw_variadic=True), ] T = TypeVar("T") class ParserDispatchMixin(IParser): def handle_class(self, path: QualifiedName, class_: type) -> Class | None: base_classes = class_.__bases__ result = Class(name=path[-1], bases=self.handle_bases(path, base_classes)) for name, member in self._iter_class_members(class_): obj = self.handle_class_member( QualifiedName([*path, Identifier(name)]), class_, member ) if isinstance(obj, Docstring): result.doc = obj elif isinstance(obj, Alias): result.aliases.append(obj) elif isinstance(obj, Field): result.fields.append(obj) elif isinstance(obj, Class): result.classes.append(obj) elif isinstance(obj, list): # list[Method] result.methods.extend(obj) elif isinstance(obj, Property): result.properties.append(obj) elif obj is None: pass else: raise AssertionError() return result def _iter_class_members(self, class_: type): seen: set[str] = set() # Iterate __dict__ keys for definition order, but resolve values # through getattr() so descriptors (staticmethod, properties, etc.) # are properly unwrapped — matching inspect.getmembers() semantics. names = list(class_.__dict__) for name in names: seen.add(name) try: value = getattr(class_, name) except AttributeError: continue yield name, value # Append inherited or lazily exposed members from dir(). for name in dir(class_): if name in seen: continue try: value = getattr(class_, name) except AttributeError: continue yield name, value def handle_class_member( self, path: QualifiedName, class_: type, member: Any ) -> Docstring | Alias | Class | list[Method] | Field | Property | None: if inspect.isroutine(member): return self.handle_method(path, member) if self._is_alias(path, member): return self.handle_alias(path, member) if inspect.isclass(member): return self.handle_class(path, member) if self._is_descriptor(member): return self.handle_property(path, member) if path[-1] == "__doc__": return self.handle_docstring(path, member) return self.handle_field(path, member) def handle_module( self, path: QualifiedName, module: types.ModuleType ) -> Module | None: result = Module(name=path[-1]) for name, member in self._iter_module_members(module): obj = self.handle_module_member( QualifiedName([*path, Identifier(name)]), module, member ) if isinstance(obj, Docstring): result.doc = obj elif isinstance(obj, Import): result.imports.add(obj) elif isinstance(obj, Alias): result.aliases.append(obj) elif isinstance(obj, Class): result.classes.append(obj) elif isinstance(obj, list): # list[Function] result.functions.extend(obj) elif isinstance(obj, Module): result.sub_modules.append(obj) elif isinstance(obj, Attribute): result.attributes.append(obj) elif isinstance(obj, TypeVar_): result.type_vars.append(obj) elif obj is None: if name == "__path__": result.is_package = True else: raise AssertionError() return result def _iter_module_members(self, module: types.ModuleType): seen: set[str] = set() # Preserve definition order for regular module globals, which reflects # pybind11 registration order, and then append lazily exposed members. for name, member in module.__dict__.items(): seen.add(name) yield name, member for name in dir(module): if name in seen: continue try: member = getattr(module, name) except AttributeError: continue yield name, member def handle_module_member( self, path: QualifiedName, module: types.ModuleType, member: Any ) -> ( Docstring | Import | Alias | Class | list[Function] | Attribute | Module | None ): member_module = self._get_value_parent_module_name(member) if ( member_module is not None and member_module != module.__name__ or path[-1] == "annotations" ): return self.handle_import(path, member) if self._is_alias(path, member): return self.handle_alias(path, member) if inspect.isroutine(member): return self.handle_function(path, member) if inspect.isclass(member): return self.handle_class(path, member) if inspect.ismodule(member): return self.handle_module(path, member) if path[-1] == "__doc__": return self.handle_docstring(path, member) return self.handle_attribute(path, member) def _get_value_parent_module_name(self, obj: Any) -> str | None: if inspect.ismodule(obj): return obj.__name__.rsplit(".", 1)[0] if inspect.isclass(obj) or inspect.isroutine(obj): return getattr(obj, "__module__", None) return None def _is_alias(self, path: QualifiedName, member: Any): if (inspect.isroutine(member) or inspect.isclass(member)) and path[ -1 ] != member.__name__: return True if inspect.ismodule(member) and member.__name__ != str(path): return True return False def _is_descriptor(self, member: Any) -> bool: # https://docs.python.org/3/glossary.html#term-descriptor # Ignore `__delete__`-only descriptors return hasattr(member, "__get__") or hasattr(member, "__set__") class BaseParser(IParser): def handle_alias(self, path: QualifiedName, origin: Any) -> Alias | None: full_name = self._get_full_name(path, origin) if full_name is None: return None return Alias( name=path[-1], origin=full_name, ) def handle_attribute(self, path: QualifiedName, value: Any) -> Attribute | None: return Attribute( name=path[-1], value=self.handle_value(value), annotation=ResolvedType(name=self.handle_type(type(value))), ) def handle_bases( self, path: QualifiedName, bases: tuple[type, ...] ) -> list[QualifiedName]: return [self.handle_type(type_) for type_ in bases if type_ is not object] def handle_docstring(self, path: QualifiedName, value: Any) -> Docstring | None: if isinstance(value, str): return Docstring(value) return None def handle_field(self, path: QualifiedName, value: Any) -> Field | None: attr = self.handle_attribute(path, value) if attr is None: return None result = Field( attribute=Attribute( name=attr.name, value=attr.value, ), modifier="static", ) if attr.annotation is not None: class_var = self.parse_annotation_str("typing.ClassVar") assert isinstance(class_var, ResolvedType) result.attribute.annotation = ResolvedType( name=class_var.name, parameters=[attr.annotation], ) return result def handle_function(self, path: QualifiedName, func: Any) -> list[Function]: doc: Docstring | None = ( Docstring(func.__doc__) if getattr(func, "__doc__", None) is not None else None ) func_name = Identifier(path[-1]) try: ( args, var_args, var_kw, defaults, kw_only_args, kw_only_defaults, annotations, ) = inspect.getfullargspec(func) func_args: dict[str, Argument] = { arg_name: Argument(name=Identifier(arg_name)) for arg_name in args } func_args["return"] = Argument( name=Identifier(), ) if var_args is not None: func_args[var_args] = Argument(name=Identifier(var_args), variadic=True) for arg_name in kw_only_args: func_args[arg_name] = Argument(name=Identifier(arg_name), kw_only=True) if var_kw is not None: func_args[var_kw] = Argument(name=Identifier(var_kw), kw_variadic=True) if defaults is not None: for i, default in enumerate(defaults): arg_name = args[len(args) - len(defaults) + i] func_args[arg_name].default = self.handle_value(default) if kw_only_defaults is not None: for arg_name, default in kw_only_defaults.items(): func_args[arg_name].default = self.handle_value(default) for arg_name, annotation in annotations.items(): if isinstance(annotation, str): func_args[arg_name].annotation = self.parse_annotation_str( annotation ) elif self._is_generic_alias(annotation): func_args[arg_name].annotation = self.parse_annotation_str( str(annotation) ) elif not isinstance(annotation, type): func_args[arg_name].annotation = self.handle_value(annotation) else: func_args[arg_name].annotation = ResolvedType( name=self.handle_type(annotation), ) if "return" in func_args: returns = func_args["return"].annotation else: returns = None return [ Function( name=func_name, args=[ arg for arg_name, arg in func_args.items() if arg_name != "return" ], returns=returns, doc=doc, ) ] except TypeError: # generic signature `f(*args, *kwargs)` return [ Function( name=func_name, args=_generic_args, doc=doc, ) ] def _is_generic_alias(self, annotation: type) -> bool: generic_alias_t: type | None = getattr(types, "GenericAlias", None) return ( generic_alias_t is not None and isinstance(annotation, generic_alias_t) or typing.get_origin(annotation) is not None ) def handle_import(self, path: QualifiedName, origin: Any) -> Import | None: full_name = self._get_full_name(path, origin) if full_name is None: return None return Import( path[-1], full_name, ) def handle_method(self, path: QualifiedName, method: Any) -> list[Method]: return [ Method(function=func, modifier=self._get_method_modifier(func.args)) for func in self.handle_function(path, method) ] def handle_value(self, value: Any) -> Value: value_type = type(value) # Use exact type match, not `isinstance()` that allows inherited types pass if value is None or value_type in (bool, int, str): return Value(repr=repr(value), is_print_safe=True) if value_type in (float, complex): try: # checks for NaN, +inf, -inf repr_str = repr(value) eval(repr_str) return Value(repr=repr_str, is_print_safe=True) except (SyntaxError, NameError): pass if value_type in (list, tuple, set): assert isinstance(value, (list, tuple, set)) if len(value) == 0: return Value(repr=f"{value_type.__name__}()", is_print_safe=True) elements: list[Value] = [self.handle_value(el) for el in value] is_print_safe = all(el.is_print_safe for el in elements) left, right = { list: "[]", tuple: "()", set: "{}", }[value_type] return Value( repr="".join([left, ", ".join(el.repr for el in elements), right]), is_print_safe=is_print_safe, ) if value_type is dict: assert isinstance(value, dict) parts = [] is_print_safe = True for k, v in value.items(): k_value = self.handle_value(k) v_value = self.handle_value(v) parts.append(f"{k_value.repr}: {v_value.repr}") is_print_safe = ( is_print_safe and k_value.is_print_safe and v_value.is_print_safe ) return Value( repr="".join(["{", ", ".join(parts), "}"]), is_print_safe=is_print_safe ) if inspect.isroutine(value): module_name = getattr(value, "__module__", None) qual_name = getattr(value, "__qualname__", None) if ( module_name is not None and "<" not in module_name and qual_name is not None and "<" not in qual_name ): if module_name == "builtins": repr_str = qual_name else: repr_str = f"{module_name}.{qual_name}" return Value(repr=repr_str, is_print_safe=True) if inspect.isclass(value): return Value(repr=str(self.handle_type(value)), is_print_safe=True) if inspect.ismodule(value): return Value(repr=value.__name__, is_print_safe=True) return Value(repr=repr(value), is_print_safe=False) def handle_type(self, type_: type) -> QualifiedName: return QualifiedName( ( Identifier(part) for part in ( *type_.__module__.split("."), *type_.__qualname__.split("."), ) ) ) def call_with_local_types(self, parameters: list[str], func: Callable[[], T]) -> T: return func() def parse_value_str(self, value: str) -> Value | InvalidExpression: return self._parse_expression_str(value) def report_error(self, error: ParserError): if isinstance(error, NameResolutionError): if error.name[0] == "module": return super().report_error(error) def _get_method_modifier(self, args: list[Argument]) -> Modifier: if len(args) == 0: return "static" name = args[0].name if name == Identifier("self"): return None elif name == Identifier("cls"): return "class" else: return "static" def _get_full_name(self, path: QualifiedName, origin: Any) -> QualifiedName | None: if inspect.ismodule(origin): origin_full_name = origin.__name__ else: module_name = getattr(origin, "__module__", None) if module_name == "__future__": return None if module_name is None: self.report_error(NameResolutionError(path)) return None qual_name = getattr(origin, "__qualname__", None) if qual_name is None: self.report_error(NameResolutionError(path)) return None # Note: __qualname__ prefix is an artefact of pybind11 # `PyCapsule.` in pybind11 2 # pybind11_detail_function_record_* in 3 match = re.match( r"(PyCapsule|pybind11_detail_function_record_[_a-zA-Z0-9]+)\.", qual_name, ) if match: qual_name = qual_name[match.end() :] origin_full_name = f"{module_name}.{qual_name}" origin_name = QualifiedName.from_str(origin_full_name) for part in origin_name: if not part.isidentifier(): self.report_error(InvalidIdentifierError(part, path)) return None return origin_name def _parse_expression_str(self, expr_str: str) -> Value | InvalidExpression: strip_expr = expr_str.strip() try: ast.parse(strip_expr) print_safe = False try: ast.literal_eval(strip_expr) print_safe = True except (ValueError, TypeError, SyntaxError, MemoryError, RecursionError): pass return Value(strip_expr, is_print_safe=print_safe) except SyntaxError: self.report_error(InvalidExpressionError(strip_expr)) return InvalidExpression(strip_expr) class ExtractSignaturesFromPybind11Docstrings(IParser): _arg_star_name_regex = re.compile( r"^\s*(?P\*{1,2})?" r"\s*(?P\w+)\s*$" ) def handle_function(self, path: QualifiedName, func: Any) -> list[Function]: result = super().handle_function(path, func) if len(result) == 1 and result[0].args == _generic_args: doc: str | None = func.__doc__ func_name = Identifier(path[-1]) if doc is not None: parsed_funcs = self.parse_function_docstring( func_name, doc.splitlines() ) if len(parsed_funcs) > 0: return parsed_funcs return result def handle_property(self, path: QualifiedName, prop: Any) -> Property | None: result = Property(name=path[-1], modifier=None) # Note: pybind *usually* does not include function name # in getter/setter signatures, e.g.: # (arg0: demo._bindings.enum.ConsoleForegroundColor) -> int # fake_path = QualifiedName((*path, Identifier(""))) if hasattr(prop, "fget") and prop.fget is not None: for func_path in [fake_path, path]: result.getter = self._fixup_parsed_getters_or_setters( self.handle_function(func_path, prop.fget) ) if result.getter is not None and result.getter.args != _generic_args: break if hasattr(prop, "fset") and prop.fset is not None: for func_path in [fake_path, path]: result.setter = self._fixup_parsed_getters_or_setters( self.handle_function(func_path, prop.fset) ) if result.setter is not None and result.setter.args != _generic_args: break if result.getter is None and result.setter is None: return None prop_doc = getattr(prop, "__doc__", None) if prop_doc is not None: result.doc = self._strip_empty_lines(prop_doc.splitlines()) if ( result.doc is not None and result.getter is not None and ( result.doc == result.getter.doc or result.doc == self._strip_empty_lines( (getattr(prop.fget, "__doc__", "") or "").splitlines() ) ) ): result.doc = None return result def parse_args_str(self, args_str: str) -> list[Argument]: split_args = self._split_args_str(args_str) if split_args is None: return _generic_args result: list[Argument] = [] kw_only = False for arg_str, annotation_str, default_str in split_args: if arg_str.strip() == "/": for arg in result: arg.pos_only = True continue if arg_str.strip() == "*": kw_only = True continue match = self._arg_star_name_regex.match(arg_str) if match is None: return _generic_args name = Identifier(match.group("name")) variadic = False kw_variadic = False stars = match.group("stars") if stars == "*": variadic = True elif stars == "**": kw_variadic = True if annotation_str is not None: annotation = self.parse_annotation_str(annotation_str) else: annotation = None if default_str is not None: default = self.parse_value_str(default_str) else: default = None result.append( Argument( name=name, default=default, annotation=annotation, variadic=variadic, kw_variadic=kw_variadic, kw_only=kw_only, ) ) return result def parse_annotation_str( self, annotation_str: str ) -> ResolvedType | InvalidExpression | Value: variants = self._split_type_union_str(annotation_str) if variants is None or len(variants) == 0: self.report_error(InvalidExpressionError(annotation_str)) return InvalidExpression(annotation_str) if len(variants) == 1: return self.parse_type_str(variants[0]) union_t = self.parse_annotation_str("typing.Union") assert isinstance(union_t, ResolvedType) return ResolvedType( name=union_t.name, parameters=[self.parse_annotation_str(variant) for variant in variants], ) def parse_type_str( self, annotation_str: str ) -> ResolvedType | InvalidExpression | Value: qname_regex = re.compile( r"^\s*(?P([_A-Za-z]\w*)?(\s*\.\s*[_A-Za-z]\w*)*)" ) annotation_str = annotation_str.strip() match = qname_regex.match(annotation_str) if match is None: return self.parse_value_str(annotation_str) qual_name = QualifiedName( Identifier(part) for part in match.group("qual_name").replace(" ", "").split(".") ) parameters_str = annotation_str[match.end("qual_name") :].strip() if len(parameters_str) == 0: parameters = None else: if parameters_str[0] != "[" or parameters_str[-1] != "]": return self.parse_value_str(annotation_str) split_parameters = self._split_parameters_str(parameters_str[1:-1]) if split_parameters is None: return self.parse_value_str(annotation_str) parameters = [ self.parse_annotation_str(param_str) for param_str in split_parameters ] return ResolvedType(name=qual_name, parameters=parameters) def parse_function_docstring( self, func_name: Identifier, doc_lines: list[str] ) -> list[Function]: if len(doc_lines) == 0: return [] top_signature_regex = re.compile( rf"^{func_name}" r"(\[(?P[\w\s,]*)])?" r"\((?P.*)\)\s*(->\s*(?P.+))?$" ) match = top_signature_regex.match(doc_lines[0]) if match is None: return [] if len(doc_lines) < 2 or doc_lines[1] != "Overloaded function.": # TODO: Update to support more complex formats. # This only supports bare type parameters. type_vars_group = match.group("type_vars") if sys.version_info < (3, 12) and type_vars_group: # This syntax is not supported before Python 3.12. return [] type_vars: list[str] = list( filter(bool, map(str.strip, (type_vars_group or "").split(","))) ) args = self.call_with_local_types( type_vars, lambda: self.parse_args_str(match.group("args")) ) returns_str = match.group("returns") if returns_str is not None: returns = self.call_with_local_types( type_vars, lambda: self.parse_annotation_str(returns_str) ) else: returns = None return [ Function( name=func_name, args=args, doc=self._strip_empty_lines(doc_lines[1:]), returns=returns, type_vars=type_vars, ) ] overload_signature_regex = re.compile( rf"^(\s*(?P\d+)\.\s*){func_name}" r"(\[(?P[\w\s,]*)])?" r"\((?P.*)\)\s*->\s*(?P.+)$" ) doc_start = 0 _dummy = Function(Identifier("")) overloads = [_dummy] for i in range(2, len(doc_lines)): match = overload_signature_regex.match(doc_lines[i]) if match: if match.group("overload_number") != f"{len(overloads)}": continue type_vars_group = match.group("type_vars") if sys.version_info < (3, 12) and type_vars_group: # This syntax is not supported before Python 3.12. continue overloads[-1].doc = self._strip_empty_lines(doc_lines[doc_start:i]) doc_start = i + 1 # TODO: Update to support more complex formats. # This only supports bare type parameters. type_vars: list[str] = list( filter( bool, map(str.strip, (type_vars_group or "").split(",")), ) ) args = self.call_with_local_types( type_vars, lambda: self.parse_args_str(match.group("args")) ) returns = self.call_with_local_types( type_vars, lambda: self.parse_annotation_str(match.group("returns")) ) overloads.append( Function( name=func_name, args=args, returns=returns, doc=None, decorators=[ # use `parse_annotation_str()` to trigger typing import Decorator(str(self.parse_annotation_str("typing.overload"))) ], type_vars=type_vars, ) ) overloads[-1].doc = self._strip_empty_lines(doc_lines[doc_start:]) return overloads[1:] def _fixup_parsed_getters_or_setters( self, funcs: list[Function] ) -> Function | None: if len(funcs) == 0: return None if len(funcs) > 1: raise RuntimeError( "Multiple overloads in property's getters/setters are not supported" ) func = funcs[0] if ( len(func.args) > 0 and not func.args[0].variadic and not func.args[0].kw_variadic and func.args[0].default is None ): func.args[0].name = Identifier("self") func.args[0].annotation = None else: pass # TODO: produce warning return func def _split_args_str( self, args_str: str ) -> list[tuple[str, str | None, str | None]] | None: result = [] closing = {"(": ")", "{": "}", "[": "]"} stack = [] i = 0 arg_begin = 0 semicolon_pos: int | None = None eq_sign_pos: int | None = None def add_arg(): nonlocal semicolon_pos nonlocal eq_sign_pos annotation = None default = None arg_end = i if eq_sign_pos is not None: arg_end = eq_sign_pos default = args_str[eq_sign_pos + 1 : i] if semicolon_pos is not None: annotation = args_str[semicolon_pos + 1 : arg_end] arg_end = semicolon_pos name = args_str[arg_begin:arg_end] result.append((name, annotation, default)) semicolon_pos = None eq_sign_pos = None while i < len(args_str): c = args_str[i] if c in "\"'": # TODO: handle triple-quoted strings too str_end = self._find_str_end(args_str, i) if str_end is None: return None i = str_end elif c in closing: stack.append(closing[c]) elif len(stack) == 0: if c == ",": add_arg() arg_begin = i + 1 elif c == ":" and semicolon_pos is None: semicolon_pos = i elif c == "=" and args_str[i : i + 2] != "==": eq_sign_pos = i elif stack[-1] == c: stack.pop() i += 1 if len(stack) != 0: return None if len(args_str[arg_begin:i].strip()) != 0: add_arg() return result def _split_type_union_str(self, type_str: str) -> list[str] | None: return self._split_str(type_str, delim="|") def _split_parameters_str(self, param_str: str) -> list[str] | None: return self._split_str(param_str, delim=",") def _split_str(self, param_str: str, delim: str): result = [] closing = {"(": ")", "{": "}", "[": "]"} stack = [] i = 0 arg_begin = 0 def add_arg(): arg_end = i param = param_str[arg_begin:arg_end] result.append(param) while i < len(param_str): c = param_str[i] if c in "\"'": # TODO: handle triple-quoted strings too str_end = self._find_str_end(param_str, i) if str_end is None: return None i = str_end elif c in closing: stack.append(closing[c]) elif len(stack) == 0: if c == delim: add_arg() arg_begin = i + 1 elif stack[-1] == c: stack.pop() i += 1 if len(stack) != 0: return None if param_str[arg_begin:i].strip() != 0: add_arg() return result def _find_str_end(self, s, start) -> int | None: for i in range(start + 1, len(s)): c = s[i] if c == "\\": # skip escaped chars continue if c == s[start]: return i return None def _strip_empty_lines(self, doc_lines: list[str]) -> Docstring | None: assert isinstance(doc_lines, list) start = 0 for start in range(0, len(doc_lines)): if len(doc_lines[start].strip()) > 0: break end = len(doc_lines) - 1 for end in range(len(doc_lines) - 1, 0, -1): if len(doc_lines[end].strip()) > 0: break result = "\n".join(doc_lines[start : end + 1]) if len(result) == 0: return None return Docstring(result) def report_error(self, error: ParserError) -> None: if isinstance(error, NameResolutionError): if error.name[0] == "pybind11_builtins": return if isinstance(error, InvalidIdentifierError): name = error.name if ( name.startswith("ItemsView[") and name.endswith("]") or name.startswith("KeysView[") and name.endswith("]") or name.startswith("ValuesView[") and name.endswith("]") ): return super().report_error(error) def handle_bases( self, path: QualifiedName, bases: tuple[type, ...] ) -> list[QualifiedName]: result = [] for base in super().handle_bases(path, bases): if base[0] == "pybind11_builtins": break result.append(base) return result pybind-pybind11-stubgen-c8167c3/pybind11_stubgen/printer.py000066400000000000000000000346661525537303700236750ustar00rootroot00000000000000from __future__ import annotations import dataclasses import logging from pybind11_stubgen.structs import ( Alias, Annotation, Argument, Attribute, Class, Docstring, Field, Function, Identifier, Import, InvalidExpression, Method, Modifier, Module, Property, ResolvedType, TypeVar_, Value, ) log = logging.getLogger("pybind11_stubgen") def indent_lines(lines: list[str], by=4) -> list[str]: return [" " * by + line for line in lines] def _referenced_local_dependency_name(expr: str) -> str | None: """Extract the local dependency name from a dotted identifier expression. Returns the first component if *expr* is a valid dotted identifier (e.g. ``"ParIter"`` -> ``"ParIter"``, ``"Outer.Inner"`` -> ``"Outer"``), or ``None`` for anything else (literals, calls, etc.). """ parts = expr.split(".") if not parts or any(not part.isidentifier() for part in parts): return None return parts[0] def _topological_sort_classes(classes: list[Class]) -> list[Class]: """Sort classes so that dependencies appear before dependents. Considers two kinds of edges: - Inheritance: base classes must appear before derived classes. - Runtime references: class-body aliases (``Foo = Bar``) and field values that name a sibling class are executable at import time, so the referenced class must already be defined. (``from __future__ import annotations`` only defers *type annotations*, not attribute/alias assignments.) Uses Kahn's algorithm. Ties are broken by input position for stability. Only references whose first identifier component names a sibling class in the current scope contribute edges. External references are ignored. """ if not classes: return classes name_to_index = {c.name: i for i, c in enumerate(classes)} name_to_class = {c.name: c for c in classes} # Build adjacency list: dependency -> [dependent, ...] # and in-degree count for each class children: dict[str, list[str]] = {c.name: [] for c in classes} in_degree: dict[str, int] = {c.name: 0 for c in classes} seen_edges: set[tuple[str, str]] = set() def _add_edge(dependency: str, dependent: str) -> None: edge = (dependency, dependent) if edge in seen_edges: return seen_edges.add(edge) children[dependency].append(dependent) in_degree[dependent] += 1 for c in classes: # Inheritance edges: base -> derived for base in c.bases: base_name = str(base[0]) if base_name in name_to_class: _add_edge(base_name, c.name) # Alias edges: ``Iterator = ParIter`` is a runtime assignment for alias in c.aliases: origin_name = str(alias.origin[0]) if origin_name in name_to_class and origin_name != c.name: _add_edge(origin_name, c.name) # Field-value edges: a print-safe field like ``Iterator = ParIter`` # (parsed as a Field rather than an Alias in some configurations) for field in c.fields: val = field.attribute.value if val is not None and val.is_print_safe: val_name = _referenced_local_dependency_name(val.repr) if ( val_name is not None and val_name in name_to_class and val_name != c.name ): _add_edge(val_name, c.name) # Initialize queue with zero in-degree classes, sorted by input position queue = sorted( [name for name, deg in in_degree.items() if deg == 0], key=lambda n: name_to_index[n], ) result = [] while queue: name = queue.pop(0) result.append(name_to_class[name]) # Sort children by input position for stable ordering for child in sorted(children[name], key=lambda n: name_to_index[n]): in_degree[child] -= 1 if in_degree[child] == 0: queue.append(child) # Re-sort queue to maintain input-position priority queue.sort(key=lambda n: name_to_index[n]) if len(result) < len(classes): remaining = [c for c in classes if c.name not in {r.name for r in result}] log.warning( "Cycle detected in class dependencies involving: %s. " "Appending in original order.", [c.name for c in remaining], ) result.extend(remaining) return result class Printer: def __init__( self, invalid_expr_as_ellipses: bool, print_value_comments: bool = False, ): self.invalid_expr_as_ellipses = invalid_expr_as_ellipses self.print_value_comments = print_value_comments def _order_classes(self, classes: list[Class]) -> list[Class]: return _topological_sort_classes(classes) def print_alias(self, alias: Alias) -> list[str]: return [f"{alias.name} = {alias.origin}"] def print_attribute(self, attr: Attribute) -> list[str]: parts = [ f"{attr.name}", ] if attr.annotation is not None: parts.append(f": {self.print_annotation(attr.annotation)}") if attr.value is not None and attr.value.is_print_safe: parts.append(f" = {self.print_value(attr.value)}") else: if attr.annotation is None: parts.append(" = ...") if attr.value is not None and self.print_value_comments: parts.append(f" # value = {self.print_value(attr.value)}") result = ["".join(parts)] if attr.doc: result.extend(self.print_docstring(attr.doc)) return result def print_argument(self, arg: Argument) -> str: parts = [] if arg.variadic: parts += ["*"] if arg.kw_variadic: parts += ["**"] parts.append(f"{arg.name}") if arg.annotation is not None: parts.append(f": {self.print_annotation(arg.annotation)}") if isinstance(arg.default, Value): if arg.default.is_print_safe: parts.append(f" = {self.print_value(arg.default)}") else: parts.append(" = ...") elif isinstance(arg.default, InvalidExpression): parts.append(f" = {self.print_invalid_exp(arg.default)}") return "".join(parts) def print_class(self, class_: Class) -> list[str]: if class_.bases: base_list = "(" + ", ".join(str(base) for base in class_.bases) + ")" else: base_list = "" return [ f"class {class_.name}{base_list}:", *indent_lines(self.print_class_body(class_)), ] def print_type_var(self, type_var: TypeVar_) -> list[str]: return [str(type_var)] def print_class_body(self, class_: Class) -> list[str]: result = [] if class_.doc is not None: result.extend(self.print_docstring(class_.doc)) for sub_class in self._order_classes(class_.classes): result.extend(self.print_class(sub_class)) modifier_order: dict[Modifier, int] = { "static": 0, "class": 1, None: 2, } for field in sorted( class_.fields, key=lambda f: (modifier_order[f.modifier], f.attribute.name) ): result.extend(self.print_field(field)) for alias in sorted(class_.aliases, key=lambda a: a.name): result.extend(self.print_alias(alias)) for method in sorted( class_.methods, key=lambda m: (modifier_order[m.modifier], m.function.name) ): result.extend(self.print_method(method)) for prop in sorted(class_.properties, key=lambda p: p.name): result.extend(self.print_property(prop)) if not result: result = ["pass"] return result def print_docstring(self, doc: Docstring) -> list[str]: return [ '"""', *( line.replace("\\", r"\\").replace('"""', r"\"\"\"") for line in doc.lstrip("\n").splitlines() ), '"""', ] def print_field(self, field: Field) -> list[str]: return self.print_attribute(field.attribute) # FIXME: modifier def print_function(self, func: Function) -> list[str]: pos_only = False kw_only = False args = [] for arg in func.args: if arg.variadic: pos_only = True kw_only = True if not pos_only and not arg.pos_only: pos_only = True args.append("/") if not kw_only and arg.kw_only: kw_only = True args.append("*") args.append(self.print_argument(arg)) if len(args) > 0 and args[0] == "/": args = args[1:] signature = [f"def {func.name}"] if func.type_vars: signature.extend(["[", ", ".join(func.type_vars), "]"]) signature.extend( [ "(", ", ".join(args), ")", ] ) if func.returns is not None: signature.append(f" -> {self.print_annotation(func.returns)}") signature.append(":") result: list[str] = [ *(f"@{decorator}" for decorator in func.decorators), "".join(signature), ] if func.doc is not None: body = self.print_docstring(func.doc) else: body = ["..."] result.extend(indent_lines(body)) return result def print_submodule_import(self, name: Identifier) -> list[str]: return [f"from . import {name}"] def print_import(self, import_: Import) -> list[str]: parent = str(import_.origin.parent) if import_.name is None: return [f"import {import_.origin}"] if len(parent) == 0: return [f"import {import_.origin} as {import_.name}"] result = f"from {parent} import {import_.origin[-1]}" if import_.name != import_.origin[-1]: result += f" as {import_.name}" return [result] def print_method(self, method: Method) -> list[str]: result = [] if method.modifier == "static": result += ["@staticmethod"] elif method.modifier == "class": result += ["@classmethod"] elif method.modifier is None: pass else: raise RuntimeError() result.extend(self.print_function(method.function)) return result def print_module(self, module: Module) -> list[str]: result = [] if module.doc is not None: result.extend(self.print_docstring(module.doc)) for import_ in sorted(module.imports, key=lambda x: (x.origin, x.name or "")): result.extend(self.print_import(import_)) for sub_module in module.sub_modules: result.extend(self.print_submodule_import(sub_module.name)) # Place __all__ above everything for attr in sorted(module.attributes, key=lambda a: a.name): if attr.name == "__all__": result.extend(self.print_attribute(attr)) break for type_var in sorted(module.type_vars, key=lambda t: t.name): result.extend(self.print_type_var(type_var)) for class_ in self._order_classes(module.classes): result.extend(self.print_class(class_)) for func in sorted(module.functions, key=lambda f: f.name): result.extend(self.print_function(func)) for attr in sorted(module.attributes, key=lambda a: a.name): if attr.name != "__all__": result.extend(self.print_attribute(attr)) for alias in module.aliases: result.extend(self.print_alias(alias)) return result def print_property(self, prop: Property) -> list[str]: if not prop.getter: # FIXME: support setter-only props return [] # FIXME: add modifier result = [] result.extend( [ "@property", *self.print_function( dataclasses.replace( prop.getter, name=prop.name, # replace getter docstring if prop.doc exists doc=prop.doc if prop.doc is not None else prop.getter.doc, ) ), ] ) if prop.setter: result.extend( [ f"@{prop.name}.setter", *self.print_function( dataclasses.replace( prop.setter, name=prop.name, # remove setter docstring if prop.doc exists doc=None if prop.doc is not None else prop.setter.doc, ) ), ] ) return result def print_value(self, value: Value) -> str: split = value.repr.split("\n", 1) if len(split) == 1: return split[0] else: return split[0] + "..." def print_type(self, type_: ResolvedType) -> str: if ( str(type_.name) == "typing.Optional" and type_.parameters is not None and len(type_.parameters) == 1 ): return f"{self.print_annotation(type_.parameters[0])} | None" if str(type_.name) == "typing.Union" and type_.parameters is not None: return " | ".join(self.print_annotation(p) for p in type_.parameters) if type_.parameters: param_str = ( "[" + ", ".join(self.print_annotation(p) for p in type_.parameters) + "]" ) else: param_str = "" return f"{type_.name}{param_str}" def print_annotation(self, annotation: Annotation) -> str: if isinstance(annotation, ResolvedType): return self.print_type(annotation) elif isinstance(annotation, Value): return self.print_value(annotation) elif isinstance(annotation, InvalidExpression): return self.print_invalid_exp(annotation) else: raise AssertionError() def print_invalid_exp(self, invalid_expr: InvalidExpression) -> str: if self.invalid_expr_as_ellipses: return "..." return invalid_expr.text pybind-pybind11-stubgen-c8167c3/pybind11_stubgen/py.typed000066400000000000000000000000001525537303700233060ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/pybind11_stubgen/structs.py000066400000000000000000000117501525537303700237060ustar00rootroot00000000000000from __future__ import annotations from dataclasses import dataclass from dataclasses import field as field_ from typing import Literal, Tuple, Union Modifier = Literal["static", "class", None] class Identifier(str): pass class Decorator(str): pass class Docstring(str): pass @dataclass class InvalidExpression: text: str def __str__(self): return f"Invalid python expression `{self.text}`" class QualifiedName(Tuple[Identifier, ...]): """Fully Qualified Name""" @classmethod def from_str(cls, name: str) -> QualifiedName: return QualifiedName(Identifier(part) for part in name.split(".")) def __str__(self): return ".".join(self) @property def parent(self) -> QualifiedName: return QualifiedName(self[:-1]) @dataclass class Value: repr: str is_print_safe: bool = False # `self.repr` is valid python and safe to print as is def __str__(self): return self.repr @dataclass class ResolvedType: name: QualifiedName parameters: list[ResolvedType | Value | InvalidExpression] | None = field_( default=None ) def __str__(self): if self.parameters: param_str = "[" + ", ".join(str(p) for p in self.parameters) + "]" else: param_str = "" return f"{self.name}{param_str}" @dataclass class Alias: name: Identifier origin: QualifiedName Annotation = Union[ResolvedType, Value, InvalidExpression] @dataclass class TypeVar_: name: Identifier constraints: list[Annotation] = field_(default_factory=list) bound: Annotation | None = field_(default=None) covariant: bool = field_(default=False) contravariant: bool = field_(default=False) def __str__(self) -> str: return ( f'{self.name} = typing.TypeVar("{self.name}"' + (", " if self.constraints else "") + (", ".join(str(c) for c in self.constraints)) + (f", bound={str(self.bound)}" if self.bound is not None else "") + (f", covariant={self.covariant}" if self.covariant else "") + (f", contravariant={self.contravariant}" if self.contravariant else "") + ")" ) @dataclass class Attribute: name: Identifier value: Value | None annotation: Annotation | None = field_(default=None) doc: Docstring | None = field_(default=None) @dataclass class Argument: name: Identifier | None pos_only: bool = field_(default=False) kw_only: bool = field_(default=False) variadic: bool = field_(default=False) # *args kw_variadic: bool = field_(default=False) # **kwargs default: Value | InvalidExpression | None = field_(default=None) annotation: Annotation | None = field_(default=None) def __str__(self): result = [] if self.variadic: result += ["*"] if self.kw_variadic: result += ["**"] result += [f"{self.name}"] if self.annotation: result += [f": {self.annotation}"] if self.default: result += [f" = {self.default}"] return "".join(result) @dataclass class Function: name: Identifier args: list[Argument] = field_(default_factory=list) returns: Annotation | None = field_(default=None) doc: Docstring | None = field_(default=None) decorators: list[Decorator] = field_(default_factory=list) type_vars: list[str] = field_(default_factory=list) def __str__(self): return ( f"{self.name}({', '.join(str(arg) for arg in self.args)}) -> {self.returns}" ) @dataclass class Property: name: Identifier modifier: Modifier doc: Docstring | None = field_(default=None) getter: Function | None = field_(default=None) setter: Function | None = field_(default=None) @dataclass class Method: function: Function modifier: Modifier @dataclass class Field: attribute: Attribute modifier: Modifier @dataclass class Class: name: Identifier doc: Docstring | None = field_(default=None) bases: list[QualifiedName] = field_(default_factory=list) classes: list[Class] = field_(default_factory=list) fields: list[Field] = field_(default_factory=list) methods: list[Method] = field_(default_factory=list) properties: list[Property] = field_(default_factory=list) aliases: list[Alias] = field_(default_factory=list) @dataclass(eq=True, frozen=True) class Import: name: Identifier | None origin: QualifiedName @dataclass class Module: name: Identifier doc: Docstring | None = field_(default=None) classes: list[Class] = field_(default_factory=list) functions: list[Function] = field_(default_factory=list) sub_modules: list[Module] = field_(default_factory=list) attributes: list[Attribute] = field_(default_factory=list) imports: set[Import] = field_(default_factory=set) aliases: list[Alias] = field_(default_factory=list) type_vars: list[TypeVar_] = field_(default_factory=list) is_package: bool = field_(default=False) pybind-pybind11-stubgen-c8167c3/pybind11_stubgen/typing_ext.py000066400000000000000000000011421525537303700243630ustar00rootroot00000000000000from __future__ import annotations class FixedSize: def __init__(self, *dim: int): self.dim: tuple[int, ...] = dim def __repr__(self): return ( f"{self.__module__}." f"{self.__class__.__qualname__}" f"({', '.join(str(d) for d in self.dim)})" ) class DynamicSize: def __init__(self, *dim: int | str): self.dim: tuple[int | str, ...] = dim def __repr__(self): return ( f"{self.__module__}." f"{self.__class__.__qualname__}" f"({', '.join(repr(d) for d in self.dim)})" ) pybind-pybind11-stubgen-c8167c3/pybind11_stubgen/writer.py000066400000000000000000000021151525537303700235060ustar00rootroot00000000000000from __future__ import annotations from pathlib import Path from pybind11_stubgen.printer import Printer from pybind11_stubgen.structs import Module class Writer: def __init__(self, stub_ext: str = "pyi"): # assert stub_extension in ["pyi", "py"] self.stub_ext: str = stub_ext def write_module( self, module: Module, printer: Printer, to: Path, sub_dir: Path | None = None ): assert to.exists() assert to.is_dir() if module.sub_modules or module.is_package or sub_dir is not None: if sub_dir is None: sub_dir = Path(module.name) module_dir = to / sub_dir module_dir.mkdir(exist_ok=True) module_file = module_dir / f"__init__.{self.stub_ext}" else: module_file = to / f"{module.name}.{self.stub_ext}" with open(module_file, "w", encoding="utf-8") as f: f.writelines(line + "\n" for line in printer.print_module(module)) for sub_module in module.sub_modules: self.write_module(sub_module, printer, to=module_dir) pybind-pybind11-stubgen-c8167c3/pyproject.toml000066400000000000000000000024751525537303700213670ustar00rootroot00000000000000[build-system] requires = ["setuptools"] build-backend = "setuptools.build_meta" [project] name = "pybind11-stubgen" description = "PEP 561 type stubs generator for pybind11 modules" version = "3.0.0" requires-python = ">=3.10" authors = [ {name = "Sergei Izmailov", email = "sergei.a.izmailov@gmail.com"}, ] maintainers = [ {name = "Axel Huebl"}, {name = "Skarn"}, {name = "Dustin Spicuzza"}, ] license = "BSD-3-Clause" license-files = ["LICENSE"] dynamic = ["readme"] [project.urls] Repository = "https://github.com/pybind/pybind11-stubgen" Issues = "https://github.com/pybind/pybind11-stubgen/issues" [dependency-groups] dev = [ "cmeel==0.59.0", "cmeel-eigen==3.4.0.2", "numpy~=1.20", "pip", "pre-commit>=4,<5", "scipy~=1.0", "typing_extensions>=4,<5", "mypy>=1.19.1", ] [tool.setuptools.packages] find = {} [tool.setuptools.dynamic] readme = {file = ["README.md"], content-type = "text/markdown"} [project.entry-points.console_scripts] pybind11-stubgen = "pybind11_stubgen.__init__:main" [tool.ruff] target-version = "py310" line-length = 88 exclude = ["tests/stubs"] [tool.ruff.lint] ignore = ["F403"] # undefined names imported (triggered by native extensions) [tool.ruff.format] quote-style = "double" indent-style = "space" [tool.ruff.lint.pycodestyle] max-line-length = 88 pybind-pybind11-stubgen-c8167c3/tests/000077500000000000000000000000001525537303700176055ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/.gitignore000066400000000000000000000000161525537303700215720ustar00rootroot00000000000000py-demo-stubs pybind-pybind11-stubgen-c8167c3/tests/README.md000066400000000000000000000004541525537303700210670ustar00rootroot00000000000000# Test project structure The setup mocks the following project structure: 1. A C++ library (C++/CMake): [`demo-lib`](demo-lib) 2. Bindings of C++ library as shared object (C++/CMake): [`py-demo/bindings`](py-demo/bindings) 3. Bindings of C++ library as python module (Python): [`py-demo`](py-demo) pybind-pybind11-stubgen-c8167c3/tests/check-demo-errors-generation.sh000077500000000000000000000023611525537303700256100ustar00rootroot00000000000000#!/bin/bash set -e if [ "$#" -lt 1 ]; then echo "Usage: $0 pybind11-vX.Y [path]" exit 1 fi resolve_path() { local path="$2" while [ -L "$path" ]; do path="$(readlink "$path")" done if [ -d "$path" ]; then (cd "$path" && pwd -P) else (cd "$(dirname "$path")" && echo "$(pwd -P)/$(basename "$path")") fi } TESTS_ROOT="$(resolve_path "$(dirname "$0")")" ERRORS_ROOT="$(resolve_path "${TESTS_ROOT}/errors/$1")" DEMO_ERRORS_FILE="${ERRORS_ROOT}/demo.errors.stderr.txt" STUBS_DIR="/tmp/out" # Stubs should never be actually written remove_demo_errors() { rm -rf "${DEMO_ERRORS_FILE}"; } check_error_messages() { ( set -o pipefail ; git diff --exit-code HEAD -- "${DEMO_ERRORS_FILE}"; ) } run_stubgen() { ( set +e ; pybind11-stubgen \ demo \ --output-dir=${STUBS_DIR} \ --exit-code \ 2> "${DEMO_ERRORS_FILE}" \ || exit 0 ) || ( echo "'pybind11-stubgen demo --exit-code' did not exit with code 1" exit 1 ) } remove_randomness_in_errors (){ sed -E -i.bak 's/0x[0-9A-Fa-f]+/0x1234abcd5678/g' "$DEMO_ERRORS_FILE" rm -f "${DEMO_ERRORS_FILE}.bak" } main () { remove_demo_errors run_stubgen remove_randomness_in_errors check_error_messages } main "$@" pybind-pybind11-stubgen-c8167c3/tests/check-demo-stubs-generation.sh000077500000000000000000000056561525537303700254460ustar00rootroot00000000000000#!/bin/bash set -e resolve_path() { local path="$1" while [ -L "$path" ]; do path="$(readlink "$path")" done if [ -d "$path" ]; then (cd "$path" && pwd -P) else (cd "$(dirname "$path")" && echo "$(pwd -P)/$(basename "$path")") fi } function parse_args() { CLEAR='\033[0m' RED='\033[0;31m' function usage() { if [ -n "$1" ]; then echo -e "${RED}👉 $1${CLEAR}\n"; fi echo "Usage: $0 --stubs-sub-dir STUBS_SUB_DIR [--numpy-array-wrap-with-annotated] [--numpy-array-use-type-var]" echo " --stubs-sub-dir stubs output dir relative to this script directory" echo " --numpy-array-wrap-with-annotated use --numpy-array-wrap-with-annotated to generate numpy array stubs" echo " --numpy-array-use-type-var use --numpy-array-use-type-var to generate numpy array stubs" exit 1 } # parse params while [[ "$#" > 0 ]]; do case $1 in --stubs-sub-dir) STUBS_SUB_DIR="$2";shift;shift;; --numpy-array-use-type-var) NUMPY_FORMAT="$1";shift;; --numpy-array-wrap-with-annotated) NUMPY_FORMAT="$1";shift;; *) usage "Unknown parameter passed: $1"; shift; shift;; esac; done # verify params if [ -z "$STUBS_SUB_DIR" ]; then usage "STUBS_SUB_DIR is not set"; fi; if [ -z "$NUMPY_FORMAT" ]; then usage "NUMPY_FORMAT is not set"; fi; TESTS_ROOT="$(resolve_path "$(dirname "$0")")" STUBS_DIR=$(resolve_path "${TESTS_ROOT}/${STUBS_SUB_DIR}") } remove_stubs() { rm -rf "${STUBS_DIR}/*" ; } get_ruff_version() { awk ' $1 == "-" && $2 == "repo:" && $3 == "https://github.com/astral-sh/ruff-pre-commit" { found = 1 next } found && $1 == "rev:" { sub(/^v/, "", $2) print $2 exit } ' "${TESTS_ROOT}/../.pre-commit-config.yaml" } run_stubgen() { pybind11-stubgen \ demo \ --output-dir=${STUBS_DIR} \ ${NUMPY_FORMAT} \ --ignore-invalid-expressions="\(anonymous namespace\)::(Enum|Unbound)| $ ) target_include_directories(demo PRIVATE $ ) target_link_libraries(demo PUBLIC Eigen3::Eigen) set_property(TARGET demo PROPERTY POSITION_INDEPENDENT_CODE ON) add_library(Demo::demo ALIAS demo) include(GNUInstallDirs) install(TARGETS demo EXPORT DemoTargets PUBLIC_HEADER DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/demo" ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} ) install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include/" DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}) set(DEMO_CMAKECONFIG_INSTALL_DIR "${CMAKE_INSTALL_DATAROOTDIR}/cmake/${PROJECT_NAME}" CACHE STRING "install path for DemoConfig.cmake") install(EXPORT DemoTargets NAMESPACE Demo:: DESTINATION ${DEMO_CMAKECONFIG_INSTALL_DIR}) include(CMakePackageConfigHelpers) write_basic_package_version_file( DemoConfigVersion.cmake VERSION ${PACKAGE_VERSION} COMPATIBILITY SameMajorVersion ) install( FILES ./DemoConfig.cmake ${CMAKE_CURRENT_BINARY_DIR}/DemoConfigVersion.cmake DESTINATION ${DEMO_CMAKECONFIG_INSTALL_DIR} ) pybind-pybind11-stubgen-c8167c3/tests/demo-lib/DemoConfig.cmake000066400000000000000000000001731525537303700243120ustar00rootroot00000000000000include(CMakeFindDependencyMacro) find_dependency(Eigen3 REQUIRED) include("${CMAKE_CURRENT_LIST_DIR}/DemoTargets.cmake") pybind-pybind11-stubgen-c8167c3/tests/demo-lib/include/000077500000000000000000000000001525537303700227205ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/demo-lib/include/demo/000077500000000000000000000000001525537303700236445ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/demo-lib/include/demo/Foo.h000066400000000000000000000003431525537303700245400ustar00rootroot00000000000000#pragma once #include namespace demo{ class CppException : public std::runtime_error { using std::runtime_error::runtime_error; }; struct Foo { void f(); struct Child { void g(); }; }; } pybind-pybind11-stubgen-c8167c3/tests/demo-lib/include/demo/Inheritance.h000066400000000000000000000021771525537303700262550ustar00rootroot00000000000000#pragma once #include namespace demo { // note: class stubs must not be sorted // https://github.com/sizmailov/pybind11-stubgen/issues/231 struct MyBase { struct Inner{}; std::string name; }; struct Derived : MyBase { int count; }; // Cross-reference test (the "cyclic" case from issue #231 / PR #275): // ParIterBase is a base class for ParIter. // ParticleContainer references ParIter (via an alias). // ParIter.__init__ takes a ParticleContainer& (annotation back-reference). // This is NOT cyclic inheritance — just interleaved name usage. struct ParIterBase { int level; }; struct ParticleContainer; // forward declaration struct ParIter : ParIterBase { ParticleContainer* container; ParIter(ParticleContainer& pc, int level); }; struct ParticleContainer { std::string name; void process(ParIter& it); }; inline ParIter::ParIter(ParticleContainer& pc, int level) : container(&pc), ParIterBase{level} {} inline void ParticleContainer::process(ParIter& it) { it.level += 1; } } pybind-pybind11-stubgen-c8167c3/tests/demo-lib/include/demo/NestedClasses.h000066400000000000000000000002541525537303700265560ustar00rootroot00000000000000#pragma once namespace demo{ struct Outer { struct Inner{ enum class NestedEnum { ONE=1, TWO }; NestedEnum value; }; Inner inner; }; } pybind-pybind11-stubgen-c8167c3/tests/demo-lib/include/demo/sublibA/000077500000000000000000000000001525537303700252255ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/demo-lib/include/demo/sublibA/ConsoleColors.h000066400000000000000000000004041525537303700301600ustar00rootroot00000000000000namespace demo{ namespace sublibA{ enum class ConsoleForegroundColor { Green = 32, Yellow = 33, Blue = 34, Magenta = 35, None_ = -1 }; enum ConsoleBackgroundColor { Green = 42, Yellow = 43, Blue = 44, Magenta = 45 }; } } pybind-pybind11-stubgen-c8167c3/tests/demo-lib/include/demo/sublibA/add.h000066400000000000000000000001021525537303700261170ustar00rootroot00000000000000namespace demo{ namespace sublibA{ int add(int a, int b); } } pybind-pybind11-stubgen-c8167c3/tests/demo-lib/src/000077500000000000000000000000001525537303700220645ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/demo-lib/src/Foo.cpp000066400000000000000000000003331525537303700233120ustar00rootroot00000000000000#include "demo/Foo.h" #include void demo::Foo::f() { std::cout << "invoked demo::Foo::f()" << std::endl; } void demo::Foo::Child::g() { std::cout << "invoked demo::Foo::Child::g()" << std::endl; } pybind-pybind11-stubgen-c8167c3/tests/demo-lib/src/sublibA/000077500000000000000000000000001525537303700234455ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/demo-lib/src/sublibA/add.cpp000066400000000000000000000001321525537303700246750ustar00rootroot00000000000000#include "demo/sublibA/add.h" int demo::sublibA::add(int a, int b) { return a + b; } pybind-pybind11-stubgen-c8167c3/tests/errors/000077500000000000000000000000001525537303700211215ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/errors/pybind11-v2.11000077700000000000000000000000001525537303700253012pybind11-v2.9ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/errors/pybind11-v2.12000077700000000000000000000000001525537303700253532pybind11-v2.11ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/errors/pybind11-v2.13000077700000000000000000000000001525537303700253552pybind11-v2.12ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/errors/pybind11-v2.9/000077500000000000000000000000001525537303700232445ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/errors/pybind11-v2.9/demo.errors.stderr.txt000066400000000000000000000043521525537303700275520ustar00rootroot00000000000000pybind11_stubgen - [ ERROR] In demo._bindings.aliases.foreign_enum_default : Invalid expression '' pybind11_stubgen - [ ERROR] In demo._bindings.eigen.dense_matrix_c : Can't find/import 'm' pybind11_stubgen - [ ERROR] In demo._bindings.eigen.dense_matrix_c : Can't find/import 'n' pybind11_stubgen - [ ERROR] In demo._bindings.eigen.dense_matrix_r : Can't find/import 'm' pybind11_stubgen - [ ERROR] In demo._bindings.eigen.dense_matrix_r : Can't find/import 'n' pybind11_stubgen - [ ERROR] In demo._bindings.eigen.four_col_matrix_r : Can't find/import 'm' pybind11_stubgen - [ ERROR] In demo._bindings.eigen.four_row_matrix_r : Can't find/import 'n' pybind11_stubgen - [ ERROR] In demo._bindings.enum.accept_defaulted_enum : Invalid expression '' pybind11_stubgen - [ ERROR] In demo._bindings.flawed_bindings.accept_unbound_enum : Invalid expression '(anonymous namespace)::Enum' pybind11_stubgen - [ ERROR] In demo._bindings.flawed_bindings.accept_unbound_enum_defaulted : Invalid expression '' pybind11_stubgen - [ ERROR] In demo._bindings.flawed_bindings.accept_unbound_type : Invalid expression '(anonymous namespace)::Unbound' pybind11_stubgen - [ ERROR] In demo._bindings.flawed_bindings.accept_unbound_type_defaulted : Invalid expression '' pybind11_stubgen - [ ERROR] In demo._bindings.flawed_bindings.get_unbound_type : Invalid expression '(anonymous namespace)::Unbound' pybind11_stubgen - [WARNING] Enum-like str representations were found with no matching mapping to the enum class location. Use `--enum-class-locations` to specify full path to the following enum(s): - ConsoleForegroundColor pybind11_stubgen - [WARNING] Raw C++ types/values were found in signatures extracted from docstrings. Please check the corresponding sections of pybind11 documentation to avoid common mistakes in binding code: - https://pybind11.readthedocs.io/en/latest/advanced/misc.html#avoiding-cpp-types-in-docstrings - https://pybind11.readthedocs.io/en/latest/advanced/functions.html#default-arguments-revisited pybind11_stubgen - [ INFO] Terminating due to previous errors pybind-pybind11-stubgen-c8167c3/tests/errors/pybind11-v3.0/000077500000000000000000000000001525537303700232345ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/errors/pybind11-v3.0/demo.errors.stderr.txt000066400000000000000000000032741525537303700275440ustar00rootroot00000000000000pybind11_stubgen - [ ERROR] In demo._bindings.aliases.foreign_enum_default : Invalid expression '' pybind11_stubgen - [ ERROR] In demo._bindings.enum.accept_defaulted_enum : Invalid expression '' pybind11_stubgen - [ ERROR] In demo._bindings.flawed_bindings.accept_unbound_enum : Invalid expression '(anonymous namespace)::Enum' pybind11_stubgen - [ ERROR] In demo._bindings.flawed_bindings.accept_unbound_enum_defaulted : Invalid expression '' pybind11_stubgen - [ ERROR] In demo._bindings.flawed_bindings.accept_unbound_type : Invalid expression '(anonymous namespace)::Unbound' pybind11_stubgen - [ ERROR] In demo._bindings.flawed_bindings.accept_unbound_type_defaulted : Invalid expression '' pybind11_stubgen - [ ERROR] In demo._bindings.flawed_bindings.get_unbound_type : Invalid expression '(anonymous namespace)::Unbound' pybind11_stubgen - [WARNING] Enum-like str representations were found with no matching mapping to the enum class location. Use `--enum-class-locations` to specify full path to the following enum(s): - ConsoleForegroundColor pybind11_stubgen - [WARNING] Raw C++ types/values were found in signatures extracted from docstrings. Please check the corresponding sections of pybind11 documentation to avoid common mistakes in binding code: - https://pybind11.readthedocs.io/en/latest/advanced/misc.html#avoiding-cpp-types-in-docstrings - https://pybind11.readthedocs.io/en/latest/advanced/functions.html#default-arguments-revisited pybind11_stubgen - [ INFO] Terminating due to previous errors pybind-pybind11-stubgen-c8167c3/tests/install-demo-module.sh000077500000000000000000000044661525537303700240310ustar00rootroot00000000000000#!/bin/bash set -e PYTHON_EXECUTABLE=$(python -c 'import sys; print(sys.executable)') resolve_path() { local path="$1" while [ -L "$path" ]; do path="$(readlink "$path")" done if [ -d "$path" ]; then (cd "$path" && pwd -P) else (cd "$(dirname "$path")" && echo "$(pwd -P)/$(basename "$path")") fi } function parse_args() { CLEAR='\033[0m' RED='\033[0;31m' function usage() { if [ -n "$1" ]; then echo -e "${RED}👉 $1${CLEAR}\n"; fi echo "Usage: $0 --pybind11-branch PYBIND11_BRANCH" echo " --pybind11-branch name of pybind11 branch" exit 1 } # parse params while [[ "$#" > 0 ]]; do case $1 in --pybind11-branch) PYBIND11_BRANCH="$2"; shift;shift;; *) usage "Unknown parameter passed: $1"; shift; shift;; esac; done # verify params if [ -z "$PYBIND11_BRANCH" ]; then usage "PYBIND11_BRANCH is not set"; fi; TESTS_ROOT="$(resolve_path "$(dirname "$0")")" PROJECT_ROOT="${TESTS_ROOT}/.." TEMP_DIR="${PROJECT_ROOT}/tmp/pybind11-${PYBIND11_BRANCH}" INSTALL_PREFIX="${TEMP_DIR}/install" BUILD_ROOT="${TEMP_DIR}/build" EXTERNAL_DIR="${TEMP_DIR}/external" } clone_pybind11() { mkdir -p "${EXTERNAL_DIR}" if [ ! -d "${EXTERNAL_DIR}/pybind11/${PYBIND11_BRANCH}" ]; then git clone \ --depth 1 \ --branch "${PYBIND11_BRANCH}" \ --single-branch \ https://github.com/pybind/pybind11.git \ "${EXTERNAL_DIR}/pybind11/${PYBIND11_BRANCH}" fi } install_pybind11() { export CMAKE_PREFIX_PATH="$(cmeel cmake)" cmake \ -S "${EXTERNAL_DIR}/pybind11/${PYBIND11_BRANCH}" \ -B "${BUILD_ROOT}/pybind11"\ -DPYTHON_EXECUTABLE=${PYTHON_EXECUTABLE} \ --fresh cmake --install "${BUILD_ROOT}/pybind11" \ --prefix "${INSTALL_PREFIX}" } install_demo() { cmake -S "${TESTS_ROOT}/demo-lib" -B "${BUILD_ROOT}/demo" cmake --build "${BUILD_ROOT}/demo" cmake --install "${BUILD_ROOT}/demo" \ --prefix "${INSTALL_PREFIX}" } install_pydemo() { ( export CMAKE_PREFIX_PATH="$(resolve_path "${INSTALL_PREFIX}"):$(cmeel cmake)"; rm -rf ${TESTS_ROOT}/py-demo/build uv pip install --python "${PYTHON_EXECUTABLE}" --force-reinstall "${TESTS_ROOT}/py-demo" ) } main () { parse_args "$@" clone_pybind11 install_pybind11 install_demo install_pydemo } main "$@" pybind-pybind11-stubgen-c8167c3/tests/py-demo/000077500000000000000000000000001525537303700211575ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/py-demo/README.rst000066400000000000000000000016051525537303700226500ustar00rootroot00000000000000 An example of C++ project with pybind11 bindings The primary purpose of this project is to test `pybind11-stubgen `_ functionality. It can be used as a C++ python module template. Project layout -------------- .. code-block:: sh ./include/demo/ # includes (.h) of C++ project ./src/ # sources (.cpp) of C++ project ./cpp_library_bindings/ # pybind11 bindings of C++ project ./external/ # root for 3rd party libraries sources (pybind11, gtests, etc.) Build module shared library --------------------------- Needed only for testing/debug .. code-block:: sh mkdir build (cd build ; cmake .. ) Install python -------------- The build step will be invoked automatically during install process .. code-block:: sh python setup.py install # regular python install is working pybind-pybind11-stubgen-c8167c3/tests/py-demo/bindings/000077500000000000000000000000001525537303700227545ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/py-demo/bindings/CMakeLists.txt000066400000000000000000000010371525537303700255150ustar00rootroot00000000000000cmake_minimum_required(VERSION 3.12) project(PyDemo LANGUAGES CXX VERSION 1.0) set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_EXTENSIONS OFF) add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/../../demo-lib ${CMAKE_BINARY_DIR}/demo-lib-build) find_package(pybind11 CONFIG REQUIRED) file(GLOB_RECURSE BINDINGS_SOURCES ./src/**.cpp ./src/**.h ) pybind11_add_module(_bindings ${BINDINGS_SOURCES}) target_include_directories(_bindings PRIVATE ./src) target_link_libraries(_bindings PRIVATE Demo::demo) pybind-pybind11-stubgen-c8167c3/tests/py-demo/bindings/src/000077500000000000000000000000001525537303700235435ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/py-demo/bindings/src/main.cpp000066400000000000000000000015431525537303700251760ustar00rootroot00000000000000#include "modules.h" PYBIND11_MODULE(_bindings, m) { bind_classes_module(m.def_submodule("classes")); bind_eigen_module(m.def_submodule("eigen")); bind_enum_module(m.def_submodule("enum")); bind_aliases_module(m.def_submodule("aliases")); bind_flawed_bindings_module(m.def_submodule("flawed_bindings")); bind_functions_module(m.def_submodule("functions")); bind_issues_module(m.def_submodule("issues")); bind_methods_module(m.def_submodule("methods")); bind_numpy_module(m.def_submodule("numpy")); bind_properties_module(m.def_submodule("properties")); bind_stl_module(m.def_submodule("stl")); bind_stl_bind_module(m.def_submodule("stl_bind")); bind_typing_module(m.def_submodule("typing")); bind_values_module(m.def_submodule("values")); bind_hidden_builtins_module(m.def_submodule("hidden_builtins")); } pybind-pybind11-stubgen-c8167c3/tests/py-demo/bindings/src/modules.h000066400000000000000000000015401525537303700253640ustar00rootroot00000000000000#pragma once #include #include "opaque_types.h" #define PYBIND11_VERSION_AT_LEAST(x,y) (PYBIND11_VERSION_MAJOR>x || ( PYBIND11_VERSION_MAJOR>=x && PYBIND11_VERSION_MINOR>=y )) namespace py = pybind11; void bind_aliases_module(py::module&& m); void bind_classes_module(py::module&& m); void bind_eigen_module(py::module&& m); void bind_enum_module(py::module&& m); void bind_flawed_bindings_module(py::module&& m); void bind_functions_module(py::module&& m); void bind_issues_module(py::module&& m); void bind_methods_module(py::module&& m); void bind_numpy_module(py::module&& m); void bind_properties_module(py::module&& m); void bind_stl_module(py::module&& m); void bind_stl_bind_module(py::module&& m); void bind_typing_module(py::module&& m); void bind_values_module(py::module&& m); void bind_hidden_builtins_module(py::module&& m); pybind-pybind11-stubgen-c8167c3/tests/py-demo/bindings/src/modules/000077500000000000000000000000001525537303700252135ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/py-demo/bindings/src/modules/aliases.cpp000066400000000000000000000045001525537303700273370ustar00rootroot00000000000000#include "modules.h" #include #include namespace aliases_detail { class Dummy { }; struct Color { }; struct Bar1 { }; struct Bar2 { }; struct Bar3 { }; struct Bar4 { }; } // namespace void bind_aliases_module(py::module &&m) { using namespace aliases_detail; { // python module as value auto &&pyDummy = py::class_(m, "Dummy"); pyDummy.def_property_readonly_static( "linalg", [](py::object &) { return py::module::import("numpy.linalg"); }); m.add_object("random", py::module::import("numpy.random")); } { auto &&pyColor = py::class_(m, "Color"); m.def("func", [](int x) { return x + 1; }); m.attr("local_type_alias") = pyColor; m.attr("local_func_alias") = m.attr("func"); } { auto &&sub = m.def_submodule("foreign_attr"); sub.attr("value") = demo::Foo(); } { auto &&sub = m.def_submodule("foreign_arg"); sub.def("set_foo", [](demo::Foo &) { return 13; }); } { auto &&sub = m.def_submodule("foreign_return"); sub.def("get_foo", []() { return demo::Foo(); }); } { auto &&sub = m.def_submodule("foreign_class_member"); auto &&pyBar = py::class_(sub, "Bar1"); pyBar.attr("foo") = demo::Foo(); } { auto &&sub = m.def_submodule("foreign_method_arg"); auto &&pyBar = py::class_(sub, "Bar2"); pyBar.def("set_foo", [](const Bar2 &, const demo::Foo &) { return 13; }); } { auto &&sub = m.def_submodule("foreign_method_return"); auto &&pyBar = py::class_(sub, "Bar3"); pyBar.def("get_foo", []() { return demo::Foo(); }); } { auto &&sub = m.def_submodule("missing_self_arg"); auto &&pyBar = py::class_(sub, "Bar4"); pyBar.def("set_foo", [](const demo::Foo &) { return 13; }); } { m.attr("foreign_type_alias") = m.attr("foreign_method_arg").attr("Bar2"); m.attr("foreign_class_alias") = m.attr("foreign_return").attr("get_foo"); } m.def( "foreign_enum_default", [](const py::object & /* color */) {}, py::arg("color") = demo::sublibA::ConsoleForegroundColor::Blue ); } pybind-pybind11-stubgen-c8167c3/tests/py-demo/bindings/src/modules/classes.cpp000066400000000000000000000050251525537303700273560ustar00rootroot00000000000000#include "modules.h" #include #include #include void bind_classes_module(py::module&&m) { { auto pyOuter = py::class_(m, "Outer"); auto pyInner = py::class_(pyOuter, "Inner"); py::enum_(pyInner, "NestedEnum") .value("ONE", demo::Outer::Inner::NestedEnum::ONE) .value("TWO", demo::Outer::Inner::NestedEnum::TWO); pyInner.def_readwrite("value", &demo::Outer::Inner::value); pyOuter.def_readwrite("inner", &demo::Outer::inner); } { py::class_ pyMyBase(m, "MyBase"); pyMyBase.def_readwrite("name", &demo::MyBase::name); py::class_(pyMyBase, "Inner"); py::class_(m, "Derived") .def_readwrite("count", &demo::Derived::count); } { auto pyFoo = py::class_(m, "Foo"); pyFoo.def(py::init<>()).def("f", &demo::Foo::f); py::class_(pyFoo, "FooChild") .def(py::init<>()) .def("g", &demo::Foo::Child::g); } // Cross-reference / "cyclic" test case (issue #231, PR #275): // Binding registration order here is ParIterBase, then ParticleContainer, // then ParIter. // ParticleContainer.Iterator is an alias to ParIter (cross-ref). // ParIter inherits ParIterBase and takes ParticleContainer in __init__. // The topological sort must put ParIterBase before ParIter; // from __future__ import annotations handles the annotation back-refs. { auto pyParIterBase = py::class_(m, "ParIterBase"); pyParIterBase.def_readwrite("level", &demo::ParIterBase::level); auto pyParticleContainer = py::class_(m, "ParticleContainer"); pyParticleContainer.def_readwrite("name", &demo::ParticleContainer::name); auto pyParIter = py::class_(m, "ParIter"); pyParIter.def(py::init(), py::arg("particle_container"), py::arg("level")); // Bind after ParIter is registered so pybind11 resolves the Python type pyParticleContainer.def("process", &demo::ParticleContainer::process); // Alias: ParticleContainer.Iterator = ParIter pyParticleContainer.attr("Iterator") = pyParIter; } { py::register_exception(m, "CppException"); } } pybind-pybind11-stubgen-c8167c3/tests/py-demo/bindings/src/modules/eigen.cpp000066400000000000000000000030071525537303700270060ustar00rootroot00000000000000#include "modules.h" #include #include void bind_eigen_module(py::module &&m) { using DenseMatrixR = Eigen::Matrix; using DenseMatrixC = Eigen::Matrix; using FixedMatrixR = Eigen::Matrix; using FixedMatrixC = Eigen::Matrix; using FourRowMatrixR = Eigen::Matrix; using FourColMatrixR = Eigen::Matrix; using SparseMatrixR = Eigen::SparseMatrix; using SparseMatrixC = Eigen::SparseMatrix; m.def("get_matrix_int", [] { return Eigen::Matrix3i{}; }); m.def("get_vector_float64", [] { return Eigen::Vector3d{}; }); m.def("accept_matrix_int", [](Eigen::Matrix3i &) {}); m.def("accept_vector_float64", [](Eigen::Vector3d &) {}); m.def("dense_matrix_r", [](DenseMatrixR &m) { return m; }); m.def("dense_matrix_c", [](DenseMatrixC &m) { return m; }); m.def("four_row_matrix_r", [](FourRowMatrixR &m) { return m; }); m.def("four_col_matrix_r", [](FourColMatrixR &m) { return m; }); m.def("sparse_matrix_r", [](SparseMatrixR &m) { return m; }); m.def("sparse_matrix_c", [](SparseMatrixC &m) { return m; }); m.def("fixed_mutator_r", [](const Eigen::Ref &) {}); m.def("fixed_mutator_c", [](const Eigen::Ref &) {}); m.def("fixed_mutator_a", [](const py::EigenDRef &) {}); } pybind-pybind11-stubgen-c8167c3/tests/py-demo/bindings/src/modules/enum.cpp000066400000000000000000000022321525537303700266620ustar00rootroot00000000000000#include "modules.h" #include #if PYBIND11_VERSION_AT_LEAST(3,0) # include #endif #if PYBIND11_VERSION_AT_LEAST(3,0) namespace { enum class NativeColor : int { Red = 1, Blue = 2, }; } // namespace #endif void bind_enum_module(py::module&&m) { py::enum_(m, "ConsoleForegroundColor") .value("Green", demo::sublibA::ConsoleForegroundColor::Green) .value("Yellow", demo::sublibA::ConsoleForegroundColor::Yellow) .value("Blue", demo::sublibA::ConsoleForegroundColor::Blue) .value("Magenta", demo::sublibA::ConsoleForegroundColor::Magenta) .value("None_", demo::sublibA::ConsoleForegroundColor::None_) .export_values(); m.def( "accept_defaulted_enum", [](const demo::sublibA::ConsoleForegroundColor &color) {}, py::arg("color") = demo::sublibA::ConsoleForegroundColor::None_); #if PYBIND11_VERSION_AT_LEAST(3,0) py::native_enum(m, "NativeColor", "enum.IntEnum") .value("Red", NativeColor::Red) .value("Blue", NativeColor::Blue) .finalize(); #endif } pybind-pybind11-stubgen-c8167c3/tests/py-demo/bindings/src/modules/flawed_bindings.cpp000066400000000000000000000013571525537303700310440ustar00rootroot00000000000000#include "modules.h" namespace { struct Unbound {}; enum Enum { ONE = 1, TWO = 2 }; } // namespace void bind_flawed_bindings_module(py::module&& m) { // This submodule will have C++ signatures in python docstrings to emulate // common mistakes in using pybind11 m.def("get_unbound_type", [] { return Unbound{}; }); m.def("accept_unbound_type", [](std::pair) { return 0; }); m.def("accept_unbound_enum", [](Enum) { return 0; }); py::class_(m, "Unbound"); py::class_(m, "Enum"); m.def( "accept_unbound_type_defaulted", [](Unbound) { return 0; }, py::arg("x") = Unbound{}); m.def( "accept_unbound_enum_defaulted", [](Enum) { return 0; }, py::arg("x") = Enum::ONE); } pybind-pybind11-stubgen-c8167c3/tests/py-demo/bindings/src/modules/functions.cpp000066400000000000000000000107071525537303700277340ustar00rootroot00000000000000#include "modules.h" #if PYBIND11_VERSION_AT_LEAST(2, 12) #include #endif #include #include #include #include #include namespace { void generic(const py::args &args, const py::kwargs &kwargs) {} class Foo { int x; public: explicit Foo(int x) : x(x) {} }; }; // namespace void bind_functions_module(py::module &&m) { m.def("add", demo::sublibA::add); { m.def( "mul", [](int x, int y) { return x * y; }, "Multiply x and y (int)", py::arg("x"), py::arg("y")); m.def( "mul", [](double p, double q) { return p * q; }, "Multiply p and q (double)", py::arg("p"), py::arg("q")); } m.def("func_w_anon_args", [](int x, int y, int z) {}); #if PYBIND11_VERSION_AT_LEAST(2, 6) m.def( "func_w_named_pos_args", [](int x, int y, int z) {}, py::arg("x"), py::arg("y"), py::arg("z"), py::pos_only()); m.def( "pos_kw_only_mix", [](int i, int j, int k) { return py::make_tuple(i, j, k); }, py::arg("i"), py::pos_only(), py::arg("j"), py::kw_only(), py::arg("k")); m.def("generic", &generic); m.def( "pos_kw_only_variadic_mix", [](int i, int j, py::args &, int k, py::kwargs &) { return py::make_tuple(i, j, k); }, py::arg("i"), py::pos_only(), py::arg("j"), py::kw_only(), py::arg("k")); #endif m.def("accept_callable", [](py::function &callable) { return callable(); }); m.def("accept_py_object", [](py::object &object) { return py::str(object); }); m.def("accept_py_handle", [](py::handle &handle) { return py::str(handle); }); #if PYBIND11_VERSION_AT_LEAST(2, 12) m.def("accept_annotated_callable", [](py::typing::Callable &callable) { return callable(13, 42); }); #endif #if PYBIND11_VERSION_AT_LEAST(2, 10) m.def("accept_frozenset", [](const py::frozenset &) {}); #endif m.def("accept_set", [](const py::set &) {}); m.def("default_int_arg", [](int n) {}, py::arg("n") = 5); m.def("default_optional_arg", [](std::optional n) {}, py::arg("n") = py::none()); { auto default_value = py::list(); default_value.append(py::int_(1)); default_value.append(py::int_(2)); default_value.append(py::int_(6)); default_value.append(py::int_(18)); m.def("default_list_arg", [](py::list &l) {}, py::arg("l") = default_value); } py::class_ pyFoo(m, "Foo"); pyFoo.def(py::init()); m.def("default_custom_arg", [](Foo &foo) {}, py::arg_v("foo", Foo(5), "Foo(5)")); m.def("pass_callback", [](std::function &callback) { return Foo(13); }); m.def("nested_types", [](std::variant, Foo> arg){ return arg; }); py::options options; options.disable_function_signatures(); m.def( "passthrough1", [](py::object obj) { return obj; }, py::doc("passthrough1[T](obj: T) -> T\n")); m.def( "passthrough2", [](py::object obj) { return obj; }, py::doc( "passthrough2(*args, **kwargs)\n" "Overloaded function.\n" "1. passthrough2() -> None\n" "2. passthrough2[T](obj: T) -> T\n"), py::arg("obj") = py::none()); m.def( "passthrough3", [](py::object obj1, py::object obj2) { return py::make_tuple(obj1, obj2); }, py::doc( "passthrough3(*args, **kwargs)\n" "Overloaded function.\n" "1. passthrough3() -> tuple[None, None]\n" "2. passthrough3[T](obj: T) -> tuple[T, None]\n" "3. passthrough3[T1, T2](obj1: T1, obj2: T2) -> tuple[T1, T2]\n"), py::arg("obj1") = py::none(), py::arg("obj2") = py::none()); m.def( "passthrough_backwards", [](py::object obj) { return obj; }, #if PY_MAJOR_VERSION > 3 || (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION >= 12) py::doc("passthrough_backwards[T](obj: T) -> T\n")); #else py::doc("passthrough_backwards(obj: U) -> U\n")); m.attr("U") = py::module::import("typing").attr("TypeVar")("U"); #endif options.enable_function_signatures(); } pybind-pybind11-stubgen-c8167c3/tests/py-demo/bindings/src/modules/hidden_builtins.cpp000066400000000000000000000005621525537303700310660ustar00rootroot00000000000000#include "modules.h" #include void bind_hidden_builtins_module(py::module&& m) { py::dict readonly_dict{}; auto types_m = py::module::import("types"); auto mappingproxy_t = types_m.attr("MappingProxyType"); auto none_t = types_m.attr("NoneType"); m.attr("mapping_proxy") = mappingproxy_t(readonly_dict); m.attr("none") = none_t(); } pybind-pybind11-stubgen-c8167c3/tests/py-demo/bindings/src/modules/issues.cpp000066400000000000000000000027451525537303700272420ustar00rootroot00000000000000#include "modules.h" void bind_issues_module(py::module &&m) { { // https://github.com/sizmailov/pybind11-stubgen/issues/51 m.def( "issue_51_catastrophic_regex", [](int *, int *) {}, R"docstring( Use-case: issue_51(os.get_handle_inheritable, os.set_handle_inheritable))docstring"); } { // https://github.com/sizmailov/pybind11-stubgen/issues/73 m.def( "issue_73_utf8_doc_chars", [] {}, py::doc("Construct a Ramsete unicycle controller.\n" "\n" "Tuning parameter (b > 0 rad²/m²) for which larger values make\n" "\n" "convergence more aggressive like a proportional term.\n" "Tuning parameter (0 rad⁻¹ < zeta < 1 rad⁻¹) for which larger\n" "values provide more damping in response.")); } { m.def("backslashes_should_be_escaped", [] {}, R"docstring( \brief A brief description of this function. A detailed description of this function. Here's some reStructuredText: :math:`x = [x, y, \theta]^T` )docstring"); } { // https://github.com/sizmailov/pybind11-stubgen/issues/86 auto cleanup_callback = []() { /* ... */ }; m.attr("_cleanup") = py::capsule(cleanup_callback); } { m.def("issue_274_docstring_leading_newline", [](){}, py::doc("\nThis is a docstring")); } } pybind-pybind11-stubgen-c8167c3/tests/py-demo/bindings/src/modules/methods.cpp000066400000000000000000000006741525537303700273710ustar00rootroot00000000000000#include "modules.h" namespace methods_detail { struct Dummy { int regular_method(int x) { return x + 1; } static int static_method(int x) { return x + 1; } }; } // namespace void bind_methods_module(py::module&& m) { using namespace methods_detail; auto &&pyDummy = py::class_(m, "Dummy"); pyDummy.def_static("static_method", &Dummy::static_method); pyDummy.def("regular_method", &Dummy::regular_method); } pybind-pybind11-stubgen-c8167c3/tests/py-demo/bindings/src/modules/numpy.cpp000066400000000000000000000006771525537303700271010ustar00rootroot00000000000000#include #include "modules.h" void bind_numpy_module(py::module&&m) { { m.def("get_ndarray_int", [] { return py::array_t{}; }); m.def("get_ndarray_float64", [] { return py::array_t{}; }); m.def("accept_ndarray_int", [](py::array_t &) {}); m.def("accept_ndarray_float64", [](py::array_t &) {}); } m.def("return_dtype", []() { return py::dtype("(m, "WithoutDoc", "No user docstring provided"); pyDummy.def_readwrite("def_readwrite", &WithoutDoc::value); pyDummy.def_property( "def_property", [](WithoutDoc &self) { return self.value; }, [](WithoutDoc self, int value) { self.value = value; }); pyDummy.def_property_readonly("def_property_readonly", [](WithoutDoc &self) { return self.value; }); pyDummy.def_readonly("def_readonly", &WithoutDoc::value); pyDummy.def_property_static( "def_property_static", [](py::object & /* self */) { return WithoutDoc::static_value; }, [](py::object & /* self */, int value) { WithoutDoc::static_value = value; }); pyDummy.def_property_readonly_static( "def_property_readonly_static", [](py::object & /* self */) { return WithoutDoc::static_value; }); } { auto &&pyDummy = py::class_( m, "WithPropDoc", "User docstring provided only to `def_` calls"); auto &&doc = py::doc("prop doc token"); pyDummy.def_readwrite("def_readwrite", &WithPropDoc::value, doc); pyDummy.def_property( "def_property", [](WithPropDoc &self) { return self.value; }, [](WithPropDoc self, int value) { self.value = value; }, doc); pyDummy.def_property_readonly( "def_property_readonly", [](WithPropDoc &self) { return self.value; }, doc); pyDummy.def_readonly("def_readonly", &WithPropDoc::value, doc); pyDummy.def_property_static( "def_property_static", [](py::object & /* self */) { return WithPropDoc::static_value; }, [](py::object & /* self */, int value) { WithPropDoc::static_value = value; }, doc); pyDummy.def_property_readonly_static( "def_property_readonly_static", [](py::object & /* self */) { return WithPropDoc::static_value; }, doc); } { auto &&pyDummy = py::class_( m, "WithGetterSetterDoc", "User docstring provided via pybind11::cpp_function(..., doc) to getters/setters, but " "NOT to `def_*(..., doc)` calls"); auto &&getter_doc = py::doc("getter doc token"); auto &&setter_doc = py::doc("setter doc token"); pyDummy.def_property( "def_property", py::cpp_function([](WithGetterSetterDoc &self) { return self.value; }, getter_doc), py::cpp_function([](WithGetterSetterDoc self, int value) { self.value = value; }, setter_doc)); pyDummy.def_property_readonly( "def_property_readonly", py::cpp_function([](WithGetterSetterDoc &self) { return self.value; }, getter_doc)); pyDummy.def_property_static( "def_property_static", py::cpp_function( [](py::object & /* self */) { return WithGetterSetterDoc::static_value; }, getter_doc), py::cpp_function([](py::object & /* self */, int value) { WithGetterSetterDoc::static_value = value; }, setter_doc)); pyDummy.def_property_readonly_static("def_property_readonly_static", py::cpp_function([](py::object & /* self */) { return WithGetterSetterDoc::static_value; }), getter_doc); } { auto &&pyDummy = py::class_( m, "WithPropAndGetterSetterDoc", "User docstring provided via pybind11::cpp_function(..., doc) to getters/setters and " "to `def_*(, doc)` calls"); auto &&prop_doc = py::doc("prop doc token"); auto &&getter_doc = py::doc("getter doc token"); auto &&setter_doc = py::doc("setter doc token"); pyDummy.def_property( "def_property", py::cpp_function([](WithPropAndGetterSetterDoc &self) { return self.value; }, getter_doc), py::cpp_function( [](WithPropAndGetterSetterDoc self, int value) { self.value = value; }, setter_doc), prop_doc); pyDummy.def_property_readonly( "def_property_readonly", py::cpp_function([](WithPropAndGetterSetterDoc &self) { return self.value; }, getter_doc), prop_doc); pyDummy.def_property_static( "def_property_static", py::cpp_function( [](py::object & /* self */) { return WithPropAndGetterSetterDoc::static_value; }, getter_doc), py::cpp_function([](py::object & /* self */, int value) { WithPropAndGetterSetterDoc::static_value = value; }, setter_doc), prop_doc); pyDummy.def_property_readonly_static( "def_property_readonly_static", py::cpp_function( [](py::object & /* self */) { return WithPropAndGetterSetterDoc::static_value; }, getter_doc), prop_doc); } } pybind-pybind11-stubgen-c8167c3/tests/py-demo/bindings/src/modules/stl.cpp000066400000000000000000000010461525537303700265220ustar00rootroot00000000000000#include #include #include "modules.h" #include #include #include void bind_stl_module(py::module &&m) { m.def("std_map", [] { return std::map>{}; }); m.def("std_vector", [] { return std::vector>{}; }); m.def("std_array", [](const std::array &a) { return a; }); m.def("std_variant", [](const std::variant> &) {}); m.def("std_optional", [](const std::optional &) {}); } pybind-pybind11-stubgen-c8167c3/tests/py-demo/bindings/src/modules/stl_bind.cpp000066400000000000000000000010251525537303700275130ustar00rootroot00000000000000#include #include #include "modules.h" #include #include void bind_stl_bind_module(py::module&&m) { py::bind_vector>>(m, "VectorPairStringDouble"); py::bind_map>>(m, "MapStringComplex"); m.def("get_complex_map", [] { return std::map>{}; }); m.def("get_vector_of_pairs", [] { return std::vector>{}; }); } pybind-pybind11-stubgen-c8167c3/tests/py-demo/bindings/src/modules/typing.cpp000066400000000000000000000003101525537303700272230ustar00rootroot00000000000000#include "modules.h" void bind_typing_module(py::module &&m) { m.def("get_sequence", [](py::sequence &seq) { return seq; }); m.def("get_buffer", [](py::buffer &buffer) { return buffer; }); } pybind-pybind11-stubgen-c8167c3/tests/py-demo/bindings/src/modules/values.cpp000066400000000000000000000023321525537303700272160ustar00rootroot00000000000000#include #include "modules.h" #include namespace values_detail { class Dummy {}; class Foo {}; } // namespace void bind_values_module(py::module &&m) { using namespace values_detail; { // python module as value auto &&pyDummy = py::class_(m, "Dummy"); pyDummy.def_property_readonly_static( "linalg", [](py::object &) { return py::module::import("numpy.linalg"); }); m.attr("random") = py::module::import("numpy.random"); } { py::list li; li.append(py::none{}); li.append(2); li.append(py::dict{}); m.attr("list_with_none") = li; } { auto pyFoo = py::class_(m, "Foo"); m.attr("foovar") = Foo(); py::list foolist; foolist.append(Foo()); foolist.append(Foo()); m.attr("foolist") = foolist; m.attr("none") = py::none(); } { m.attr("t_10ms") = std::chrono::milliseconds(10); m.attr("t_20ns") = std::chrono::nanoseconds(20); m.attr("t_30s") = std::chrono::seconds(30); m.def("add_day", [](std::chrono::system_clock::time_point &t) { return t + std::chrono::hours(24); }); } } pybind-pybind11-stubgen-c8167c3/tests/py-demo/bindings/src/opaque_types.h000066400000000000000000000004531525537303700264340ustar00rootroot00000000000000#pragma once #include #include #include using MapStringComplex = std::map>; using VectorPairStringDouble = std::vector>; PYBIND11_MAKE_OPAQUE(MapStringComplex); PYBIND11_MAKE_OPAQUE(VectorPairStringDouble); pybind-pybind11-stubgen-c8167c3/tests/py-demo/demo/000077500000000000000000000000001525537303700221035ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/py-demo/demo/__init__.py000066400000000000000000000002661525537303700242200ustar00rootroot00000000000000# Mock common layout library mixed of C/C++ core and pure python # C++-based modules are prefixed with underscore from . import pure_python from .core import * # version = "0.0.0" pybind-pybind11-stubgen-c8167c3/tests/py-demo/demo/core.py000066400000000000000000000000311525537303700233770ustar00rootroot00000000000000from ._bindings import * pybind-pybind11-stubgen-c8167c3/tests/py-demo/demo/pure_python/000077500000000000000000000000001525537303700244575ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/py-demo/demo/pure_python/__init__.py000066400000000000000000000000511525537303700265640ustar00rootroot00000000000000from . import classes, functions, values pybind-pybind11-stubgen-c8167c3/tests/py-demo/demo/pure_python/classes.py000066400000000000000000000001451525537303700264660ustar00rootroot00000000000000class A: """A""" class B(A): """B""" class C(B): """C""" class X(object): pass pybind-pybind11-stubgen-c8167c3/tests/py-demo/demo/pure_python/functions.py000066400000000000000000000012541525537303700270430ustar00rootroot00000000000000from __future__ import annotations import sys import typing if sys.version_info[:2] >= (3, 8): from .functions_3_8_plus import args_mix if sys.version_info[:2] >= (3, 9): from .functions_3_9_plus import generic_alias_annotation class _Dummy: @staticmethod def foo(): return 42 def search(a: int, b: list[int]) -> int: ... def builtin_function_as_default_arg(func: type(len) = len): ... def function_as_default_arg(func: type(search) = search): ... def lambda_as_default_arg(callback=lambda val: 0): ... def static_method_as_default_arg(callback=_Dummy.foo): ... def accept_frozenset(arg: typing.FrozenSet[int | float]) -> int | None: pass pybind-pybind11-stubgen-c8167c3/tests/py-demo/demo/pure_python/functions_3_8_plus.py000066400000000000000000000005551525537303700305620ustar00rootroot00000000000000import typing class Token: pass class Expression: pass def args_mix( a: int, b: float = 0.5, /, c: str = "", *args: int, x: int = 1, y=int, **kwargs: typing.Dict[int, str], ): ... def nested_current_module_annotations( tokens: list[Token], expr: typing.Optional[Expression] = None ) -> dict[str, Expression]: ... pybind-pybind11-stubgen-c8167c3/tests/py-demo/demo/pure_python/functions_3_9_plus.py000066400000000000000000000001441525537303700305550ustar00rootroot00000000000000def generic_alias_annotation( a: list[tuple[int]], b: dict[int, str], ) -> list[float]: ... pybind-pybind11-stubgen-c8167c3/tests/py-demo/demo/pure_python/values.py000066400000000000000000000001421525537303700263250ustar00rootroot00000000000000from typing import Callable, Dict callables_dict: Dict[str, Callable] = {"len": len, "int": int} pybind-pybind11-stubgen-c8167c3/tests/py-demo/pyproject.toml000066400000000000000000000002111525537303700240650ustar00rootroot00000000000000[build-system] requires = [ "setuptools>=42", "wheel", "ninja", "cmake>=3.12", ] build-backend = "setuptools.build_meta" pybind-pybind11-stubgen-c8167c3/tests/py-demo/setup.py000066400000000000000000000132741525537303700227000ustar00rootroot00000000000000import os import re import subprocess import sys from pathlib import Path from setuptools import Extension, find_packages, setup from setuptools.command.build_ext import build_ext # Convert distutils Windows platform specifiers to CMake -A arguments PLAT_TO_CMAKE = { "win32": "Win32", "win-amd64": "x64", "win-arm32": "ARM", "win-arm64": "ARM64", } # A CMakeExtension needs a sourcedir instead of a file list. # The name must be the _single_ output extension from the CMake build. # If you need multiple extensions, see scikit-build. class CMakeExtension(Extension): def __init__(self, name: str, sourcedir: str = "") -> None: super().__init__(name, sources=[]) self.sourcedir = os.fspath(Path(sourcedir).resolve()) class CMakeBuild(build_ext): def build_extension(self, ext: CMakeExtension) -> None: # Must be in this form due to bug in .resolve() only fixed in Python 3.10+ ext_fullpath = Path.cwd() / self.get_ext_fullpath(ext.name) extdir = ext_fullpath.parent.resolve() # Using this requires trailing slash for auto-detection & inclusion of # auxiliary "native" libs debug = int(os.environ.get("DEBUG", 0)) if self.debug is None else self.debug cfg = "Debug" if debug else "Release" # CMake lets you override the generator - we need to check this. # Can be set with Conda-Build, for example. cmake_generator = os.environ.get("CMAKE_GENERATOR", "") # Set Python_EXECUTABLE instead if you use PYBIND11_FINDPYTHON # EXAMPLE_VERSION_INFO shows you how to pass a value into the C++ code # from Python. cmake_args = [ f"-DCMAKE_LIBRARY_OUTPUT_DIRECTORY={extdir}{os.sep}", f"-DPYTHON_EXECUTABLE={sys.executable}", f"-DCMAKE_BUILD_TYPE={cfg}", # not used on MSVC, but no harm ] build_args = [] # Adding CMake arguments set as environment variable # (needed e.g. to build for ARM OSx on conda-forge) if "CMAKE_ARGS" in os.environ: cmake_args += [item for item in os.environ["CMAKE_ARGS"].split(" ") if item] if "CMAKE_PREFIX_PATH" in os.environ: cmake_args += [f"-DCMAKE_PREFIX_PATH={os.environ['CMAKE_PREFIX_PATH']}"] # In this example, we pass in the version to C++. You might not need to. cmake_args += [f"-DEXAMPLE_VERSION_INFO={self.distribution.get_version()}"] if self.compiler.compiler_type != "msvc": # Using Ninja-build since it a) is available as a wheel and b) # multithreads automatically. MSVC would require all variables be # exported for Ninja to pick it up, which is a little tricky to do. # Users can override the generator with CMAKE_GENERATOR in CMake # 3.15+. if not cmake_generator or cmake_generator == "Ninja": try: import ninja ninja_executable_path = Path(ninja.BIN_DIR) / "ninja" cmake_args += [ "-GNinja", f"-DCMAKE_MAKE_PROGRAM:FILEPATH={ninja_executable_path}", ] except ImportError: pass else: # Single config generators are handled "normally" single_config = any(x in cmake_generator for x in {"NMake", "Ninja"}) # CMake allows an arch-in-generator style for backward compatibility contains_arch = any(x in cmake_generator for x in {"ARM", "Win64"}) # Specify the arch if using MSVC generator, but only if it doesn't # contain a backward-compatibility arch spec already in the # generator name. if not single_config and not contains_arch: cmake_args += ["-A", PLAT_TO_CMAKE[self.plat_name]] # Multi-config generators have a different way to specify configs if not single_config: cmake_args += [ f"-DCMAKE_LIBRARY_OUTPUT_DIRECTORY_{cfg.upper()}={extdir}" ] build_args += ["--config", cfg] if sys.platform.startswith("darwin"): # Cross-compile support for macOS - respect ARCHFLAGS if set archs = re.findall(r"-arch (\S+)", os.environ.get("ARCHFLAGS", "")) if archs: cmake_args += ["-DCMAKE_OSX_ARCHITECTURES={}".format(";".join(archs))] # Set CMAKE_BUILD_PARALLEL_LEVEL to control the parallel build level # across all generators. if "CMAKE_BUILD_PARALLEL_LEVEL" not in os.environ: # self.parallel is a Python 3 only way to set parallel jobs by hand # using -j in the build_ext call, not supported by pip or PyPA-build. if hasattr(self, "parallel") and self.parallel: # CMake 3.12+ only. build_args += [f"-j{self.parallel}"] build_temp = Path(self.build_temp) / ext.name if not build_temp.exists(): build_temp.mkdir(parents=True) subprocess.run( ["cmake", ext.sourcedir, *cmake_args], cwd=build_temp, check=True ) subprocess.run( ["cmake", "--build", ".", *build_args], cwd=build_temp, check=True ) setup( name="py-demo", version="0.0.0", author="Sergei Izmailov", author_email="sergei.a.izmailov@gmail.com", description="Demo package to test stub generation", long_description=open("README.rst").read(), ext_modules=[CMakeExtension("demo._bindings", "bindings")], packages=find_packages(), cmdclass=dict(build_ext=CMakeBuild), url="https://github.com/sizmailov/pybind11-project-example", zip_safe=False, install_requires=["numpy"], ) pybind-pybind11-stubgen-c8167c3/tests/stubs/000077500000000000000000000000001525537303700207455ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/000077500000000000000000000000001525537303700226455ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v2.11000077700000000000000000000000001525537303700312122../python-3.11/pybind11-v2.11ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v2.12000077700000000000000000000000001525537303700312142../python-3.11/pybind11-v2.12ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v2.13000077700000000000000000000000001525537303700312162../python-3.11/pybind11-v2.13ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/000077500000000000000000000000001525537303700247605ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/numpy-array-use-type-var000077700000000000000000000000001525537303700427312../../python-3.11/pybind11-v3.0/numpy-array-use-type-varustar00rootroot00000000000000numpy-array-wrap-with-annotated/000077500000000000000000000000001525537303700330605ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0demo/000077500000000000000000000000001525537303700340045ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/numpy-array-wrap-with-annotated__init__.pyi000066400000000000000000000012021525537303700362610ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/numpy-array-wrap-with-annotated/demofrom __future__ import annotations from demo._bindings import ( aliases, classes, eigen, enum, flawed_bindings, functions, hidden_builtins, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) from . import _bindings, core, pure_python __all__: list[str] = [ "aliases", "classes", "core", "eigen", "enum", "flawed_bindings", "functions", "hidden_builtins", "issues", "methods", "numpy", "properties", "pure_python", "stl", "stl_bind", "typing", "values", "version", ] version: str = "0.0.0" _bindings/000077500000000000000000000000001525537303700357405ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/numpy-array-wrap-with-annotated/demo__init__.pyi000066400000000000000000000010041525537303700402150ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations from . import ( aliases, classes, eigen, enum, flawed_bindings, functions, hidden_builtins, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) __all__: list[str] = [ "aliases", "classes", "eigen", "enum", "flawed_bindings", "functions", "hidden_builtins", "issues", "methods", "numpy", "properties", "stl", "stl_bind", "typing", "values", ] aliases/000077500000000000000000000000001525537303700373615ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindings__init__.pyi000066400000000000000000000021441525537303700416440ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import typing import demo._bindings.enum import numpy from demo._bindings.aliases.foreign_method_arg import Bar2 as foreign_type_alias from demo._bindings.aliases.foreign_return import get_foo as foreign_class_alias from numpy import random from . import ( foreign_arg, foreign_attr, foreign_class_member, foreign_method_arg, foreign_method_return, foreign_return, missing_self_arg, ) __all__: list[str] = [ "Color", "Dummy", "foreign_arg", "foreign_attr", "foreign_class_alias", "foreign_class_member", "foreign_enum_default", "foreign_method_arg", "foreign_method_return", "foreign_return", "foreign_type_alias", "func", "local_func_alias", "local_type_alias", "missing_self_arg", "random", ] class Dummy: linalg = numpy.linalg class Color: pass def foreign_enum_default( color: typing.Any = demo._bindings.enum.ConsoleForegroundColor.Blue, ) -> None: ... def func(arg0: typing.SupportsInt | typing.SupportsIndex) -> int: ... local_type_alias = Color local_func_alias = func foreign_arg.pyi000066400000000000000000000002371525537303700423700ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["set_foo"] def set_foo(arg0: demo._bindings.classes.Foo) -> int: ... foreign_attr.pyi000066400000000000000000000002631525537303700425700ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["value"] value: demo._bindings.classes.Foo # value = foreign_class_member.pyi000066400000000000000000000003571525537303700442560ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import typing import demo._bindings.classes __all__: list[str] = ["Bar1"] class Bar1: foo: typing.ClassVar[ demo._bindings.classes.Foo ] # value = foreign_method_arg.pyi000066400000000000000000000002621525537303700437260ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar2"] class Bar2: def set_foo(self, arg0: demo._bindings.classes.Foo) -> int: ... foreign_method_return.pyi000066400000000000000000000002651525537303700444770ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar3"] class Bar3: @staticmethod def get_foo() -> demo._bindings.classes.Foo: ... foreign_return.pyi000066400000000000000000000002261525537303700431340ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["get_foo"] def get_foo() -> demo._bindings.classes.Foo: ... missing_self_arg.pyi000066400000000000000000000002541525537303700434200ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar4"] class Bar4: def set_foo(self: demo._bindings.classes.Foo) -> int: ... classes.pyi000066400000000000000000000046021525537303700401220ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "CppException", "Derived", "Foo", "MyBase", "Outer", "ParIter", "ParIterBase", "ParticleContainer", ] class Outer: class Inner: class NestedEnum: """ Members: ONE TWO """ ONE: typing.ClassVar[Outer.Inner.NestedEnum] # value = TWO: typing.ClassVar[Outer.Inner.NestedEnum] # value = __members__: typing.ClassVar[ dict[str, Outer.Inner.NestedEnum] ] # value = {'ONE': , 'TWO': } def __eq__(self, other: typing.Any) -> bool: ... def __getstate__(self) -> int: ... def __hash__(self) -> int: ... def __index__(self) -> int: ... def __init__( self, value: typing.SupportsInt | typing.SupportsIndex ) -> None: ... def __int__(self) -> int: ... def __ne__(self, other: typing.Any) -> bool: ... def __repr__(self) -> str: ... def __setstate__( self, state: typing.SupportsInt | typing.SupportsIndex ) -> None: ... def __str__(self) -> str: ... @property def name(self) -> str: ... @property def value(self) -> int: ... value: Outer.Inner.NestedEnum inner: Outer.Inner class MyBase: class Inner: pass name: str class Derived(MyBase): @property def count(self) -> int: ... @count.setter def count(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None: ... class Foo: class FooChild: def __init__(self) -> None: ... def g(self) -> None: ... def __init__(self) -> None: ... def f(self) -> None: ... class ParIterBase: @property def level(self) -> int: ... @level.setter def level(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None: ... class ParIter(ParIterBase): def __init__( self, particle_container: ParticleContainer, level: typing.SupportsInt | typing.SupportsIndex, ) -> None: ... class ParticleContainer: name: str Iterator = ParIter def process(self, arg0: ParIter) -> None: ... class CppException(Exception): pass eigen.pyi000066400000000000000000000045421525537303700375570ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing import numpy import numpy.typing import scipy.sparse __all__: list[str] = [ "accept_matrix_int", "accept_vector_float64", "dense_matrix_c", "dense_matrix_r", "fixed_mutator_a", "fixed_mutator_c", "fixed_mutator_r", "four_col_matrix_r", "four_row_matrix_r", "get_matrix_int", "get_vector_float64", "sparse_matrix_c", "sparse_matrix_r", ] def accept_matrix_int( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.int32, "[3, 3]"], ) -> None: ... def accept_vector_float64( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, "[3, 1]"], ) -> None: ... def dense_matrix_c( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.float32, "[m, n]"], ) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[m, n]"]: ... def dense_matrix_r( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.float32, "[m, n]"], ) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[m, n]"]: ... def fixed_mutator_a( arg0: typing.Annotated[ numpy.typing.NDArray[numpy.float32], "[5, 6]", "flags.writeable" ], ) -> None: ... def fixed_mutator_c( arg0: typing.Annotated[ numpy.typing.NDArray[numpy.float32], "[5, 6]", "flags.writeable", "flags.f_contiguous", ], ) -> None: ... def fixed_mutator_r( arg0: typing.Annotated[ numpy.typing.NDArray[numpy.float32], "[5, 6]", "flags.writeable", "flags.c_contiguous", ], ) -> None: ... def four_col_matrix_r( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.float32, "[m, 4]"], ) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[m, 4]"]: ... def four_row_matrix_r( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.float32, "[4, n]"], ) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, n]"]: ... def get_matrix_int() -> typing.Annotated[ numpy.typing.NDArray[numpy.int32], "[3, 3]" ]: ... def get_vector_float64() -> typing.Annotated[ numpy.typing.NDArray[numpy.float64], "[3, 1]" ]: ... def sparse_matrix_c( arg0: typing.Annotated[scipy.sparse.csc_matrix, numpy.float32], ) -> typing.Annotated[scipy.sparse.csc_matrix, numpy.float32]: ... def sparse_matrix_r( arg0: typing.Annotated[scipy.sparse.csr_matrix, numpy.float32], ) -> typing.Annotated[scipy.sparse.csr_matrix, numpy.float32]: ... enum.pyi000066400000000000000000000050501525537303700374270ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import enum import typing __all__: list[str] = [ "Blue", "ConsoleForegroundColor", "Green", "Magenta", "NativeColor", "None_", "Yellow", "accept_defaulted_enum", ] class ConsoleForegroundColor: """ Members: Green Yellow Blue Magenta None_ """ Blue: typing.ClassVar[ ConsoleForegroundColor ] # value = Green: typing.ClassVar[ ConsoleForegroundColor ] # value = Magenta: typing.ClassVar[ ConsoleForegroundColor ] # value = None_: typing.ClassVar[ ConsoleForegroundColor ] # value = Yellow: typing.ClassVar[ ConsoleForegroundColor ] # value = __members__: typing.ClassVar[ dict[str, ConsoleForegroundColor] ] # value = {'Green': , 'Yellow': , 'Blue': , 'Magenta': , 'None_': } def __eq__(self, other: typing.Any) -> bool: ... def __getstate__(self) -> int: ... def __hash__(self) -> int: ... def __index__(self) -> int: ... def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None: ... def __int__(self) -> int: ... def __ne__(self, other: typing.Any) -> bool: ... def __repr__(self) -> str: ... def __setstate__( self, state: typing.SupportsInt | typing.SupportsIndex ) -> None: ... def __str__(self) -> str: ... @property def name(self) -> str: ... @property def value(self) -> int: ... class NativeColor(enum.IntEnum): """ An enumeration. """ Blue: typing.ClassVar[NativeColor] # value = Red: typing.ClassVar[NativeColor] # value = @classmethod def __new__(cls, value): ... def accept_defaulted_enum( color: ConsoleForegroundColor = ConsoleForegroundColor.None_, ) -> None: ... Blue: ConsoleForegroundColor # value = Green: ConsoleForegroundColor # value = Magenta: ConsoleForegroundColor # value = None_: ConsoleForegroundColor # value = Yellow: ConsoleForegroundColor # value = flawed_bindings.pyi000066400000000000000000000011461525537303700416040ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "Enum", "Unbound", "accept_unbound_enum", "accept_unbound_enum_defaulted", "accept_unbound_type", "accept_unbound_type_defaulted", "get_unbound_type", ] class Unbound: pass class Enum: pass def accept_unbound_enum(arg0: ...) -> int: ... def accept_unbound_enum_defaulted(x: Enum = ...) -> int: ... def accept_unbound_type( arg0: tuple[..., typing.SupportsInt | typing.SupportsIndex], ) -> int: ... def accept_unbound_type_defaulted(x: Unbound = ...) -> int: ... def get_unbound_type() -> ...: ... functions.pyi000066400000000000000000000067211525537303700405010ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import collections.abc import typing __all__: list[str] = [ "Foo", "U", "accept_annotated_callable", "accept_callable", "accept_frozenset", "accept_py_handle", "accept_py_object", "accept_set", "add", "default_custom_arg", "default_int_arg", "default_list_arg", "default_optional_arg", "func_w_anon_args", "func_w_named_pos_args", "generic", "mul", "nested_types", "pass_callback", "passthrough1", "passthrough2", "passthrough3", "passthrough_backwards", "pos_kw_only_mix", "pos_kw_only_variadic_mix", ] class Foo: def __init__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None: ... def accept_annotated_callable( arg0: collections.abc.Callable[ [ typing.SupportsInt | typing.SupportsIndex, typing.SupportsInt | typing.SupportsIndex, ], int, ], ) -> typing.Any: ... def accept_callable(arg0: collections.abc.Callable) -> typing.Any: ... def accept_frozenset(arg0: frozenset) -> None: ... def accept_py_handle(arg0: typing.Any) -> str: ... def accept_py_object(arg0: typing.Any) -> str: ... def accept_set(arg0: set) -> None: ... def add( arg0: typing.SupportsInt | typing.SupportsIndex, arg1: typing.SupportsInt | typing.SupportsIndex, ) -> int: ... def default_custom_arg(foo: Foo = Foo(5)) -> None: ... def default_int_arg(n: typing.SupportsInt | typing.SupportsIndex = 5) -> None: ... def default_list_arg(l: list = [1, 2, 6, 18]) -> None: ... def default_optional_arg( n: typing.SupportsInt | typing.SupportsIndex | None = None, ) -> None: ... def func_w_anon_args( arg0: typing.SupportsInt | typing.SupportsIndex, arg1: typing.SupportsInt | typing.SupportsIndex, arg2: typing.SupportsInt | typing.SupportsIndex, ) -> None: ... def func_w_named_pos_args( x: typing.SupportsInt | typing.SupportsIndex, y: typing.SupportsInt | typing.SupportsIndex, z: typing.SupportsInt | typing.SupportsIndex, ) -> None: ... def generic(*args, **kwargs) -> None: ... @typing.overload def mul( x: typing.SupportsInt | typing.SupportsIndex, y: typing.SupportsInt | typing.SupportsIndex, ) -> int: """ Multiply x and y (int) """ @typing.overload def mul( p: typing.SupportsFloat | typing.SupportsIndex, q: typing.SupportsFloat | typing.SupportsIndex, ) -> float: """ Multiply p and q (double) """ def nested_types(arg0: collections.abc.Sequence[Foo] | Foo) -> list[Foo] | Foo: ... def pass_callback(arg0: collections.abc.Callable[[Foo], Foo]) -> Foo: ... def passthrough1(*args, **kwargs): """ passthrough1[T](obj: T) -> T """ @typing.overload def passthrough2() -> None: """ 2. passthrough2[T](obj: T) -> T """ @typing.overload def passthrough3() -> tuple[None, None]: """ 2. passthrough3[T](obj: T) -> tuple[T, None] 3. passthrough3[T1, T2](obj1: T1, obj2: T2) -> tuple[T1, T2] """ def passthrough_backwards(obj: U) -> U: ... def pos_kw_only_mix( i: typing.SupportsInt | typing.SupportsIndex, /, j: typing.SupportsInt | typing.SupportsIndex, *, k: typing.SupportsInt | typing.SupportsIndex, ) -> tuple[int, int, int]: ... def pos_kw_only_variadic_mix( i: typing.SupportsInt | typing.SupportsIndex, /, j: typing.SupportsInt | typing.SupportsIndex, *args, k: typing.SupportsInt | typing.SupportsIndex, **kwargs, ) -> tuple[int, int, int]: ... U: typing.TypeVar # value = ~U hidden_builtins.pyi000066400000000000000000000002571525537303700416330ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import types __all__: list[str] = ["mapping_proxy", "none"] mapping_proxy: types.MappingProxyType # value = mappingproxy({}) none = None issues.pyi000066400000000000000000000022401525537303700377740ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "backslashes_should_be_escaped", "issue_51_catastrophic_regex", "issue_73_utf8_doc_chars", "issue_274_docstring_leading_newline", ] def backslashes_should_be_escaped() -> None: """ \\brief A brief description of this function. A detailed description of this function. Here's some reStructuredText: :math:`x = [x, y, \\theta]^T` """ def issue_274_docstring_leading_newline() -> None: """ This is a docstring """ def issue_51_catastrophic_regex( arg0: typing.SupportsInt | typing.SupportsIndex, arg1: typing.SupportsInt | typing.SupportsIndex, ) -> None: """ Use-case: issue_51(os.get_handle_inheritable, os.set_handle_inheritable) """ def issue_73_utf8_doc_chars() -> None: """ Construct a Ramsete unicycle controller. Tuning parameter (b > 0 rad²/m²) for which larger values make convergence more aggressive like a proportional term. Tuning parameter (0 rad⁻¹ < zeta < 1 rad⁻¹) for which larger values provide more damping in response. """ _cleanup: typing.Any # value = methods.pyi000066400000000000000000000004551525537303700401320ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = ["Dummy"] class Dummy: @staticmethod def static_method(arg0: typing.SupportsInt | typing.SupportsIndex) -> int: ... def regular_method( self, arg0: typing.SupportsInt | typing.SupportsIndex ) -> int: ... numpy.pyi000066400000000000000000000011741525537303700376360ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing import numpy import numpy.typing __all__: list[str] = [ "accept_ndarray_float64", "accept_ndarray_int", "get_ndarray_float64", "get_ndarray_int", "return_dtype", ] def accept_ndarray_float64( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.float64], ) -> None: ... def accept_ndarray_int( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.int32], ) -> None: ... def get_ndarray_float64() -> numpy.typing.NDArray[numpy.float64]: ... def get_ndarray_int() -> numpy.typing.NDArray[numpy.int32]: ... def return_dtype() -> numpy.dtype[typing.Any]: ... properties.pyi000066400000000000000000000054731525537303700406700ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "WithGetterSetterDoc", "WithPropAndGetterSetterDoc", "WithPropDoc", "WithoutDoc", ] class WithoutDoc: """ No user docstring provided """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 @property def def_property(self) -> int: ... @def_property.setter def def_property(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None: ... @property def def_property_readonly(self) -> int: ... @property def def_readonly(self) -> int: ... @property def def_readwrite(self) -> int: ... @def_readwrite.setter def def_readwrite( self, arg0: typing.SupportsInt | typing.SupportsIndex ) -> None: ... class WithPropDoc: """ User docstring provided only to `def_` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 @property def def_property(self) -> int: """ prop doc token """ @def_property.setter def def_property(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None: ... @property def def_property_readonly(self) -> int: """ prop doc token """ @property def def_readonly(self) -> int: """ prop doc token """ @property def def_readwrite(self) -> int: """ prop doc token """ @def_readwrite.setter def def_readwrite( self, arg0: typing.SupportsInt | typing.SupportsIndex ) -> None: ... class WithGetterSetterDoc: """ User docstring provided via pybind11::cpp_function(..., doc) to getters/setters, but NOT to `def_*(..., doc)` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 @property def def_property(self) -> int: """ getter doc token """ @def_property.setter def def_property(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None: """ setter doc token """ @property def def_property_readonly(self) -> int: """ getter doc token """ class WithPropAndGetterSetterDoc: """ User docstring provided via pybind11::cpp_function(..., doc) to getters/setters and to `def_*(, doc)` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 @property def def_property(self) -> int: """ prop doc token """ @def_property.setter def def_property(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None: ... @property def def_property_readonly(self) -> int: """ prop doc token """ stl.pyi000066400000000000000000000015021525537303700372630ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import collections.abc import typing __all__: list[str] = [ "std_array", "std_map", "std_optional", "std_variant", "std_vector", ] def std_array( arg0: typing.Annotated[ collections.abc.Sequence[typing.SupportsInt | typing.SupportsIndex], "FixedSize(3)", ], ) -> typing.Annotated[list[int], "FixedSize(3)"]: ... def std_map() -> dict[int, complex]: ... def std_optional(arg0: typing.SupportsInt | typing.SupportsIndex | None) -> None: ... def std_variant( arg0: typing.SupportsInt | typing.SupportsIndex | typing.SupportsFloat | typing.SupportsIndex | tuple[ typing.SupportsInt | typing.SupportsIndex, typing.SupportsInt | typing.SupportsIndex, ], ) -> None: ... def std_vector() -> list[tuple[int, float]]: ... stl_bind.pyi000066400000000000000000000110261525537303700402610ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import collections.abc import typing __all__: list[str] = [ "MapStringComplex", "VectorPairStringDouble", "get_complex_map", "get_vector_of_pairs", ] class VectorPairStringDouble: __hash__: typing.ClassVar[None] = None def __bool__(self) -> bool: """ Check whether the list is nonempty """ def __contains__( self, x: tuple[str, typing.SupportsFloat | typing.SupportsIndex] ) -> bool: """ Return true the container contains ``x`` """ @typing.overload def __delitem__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None: """ Delete the list elements at index ``i`` """ @typing.overload def __delitem__(self, arg0: slice) -> None: """ Delete list elements using a slice object """ def __eq__(self, arg0: VectorPairStringDouble) -> bool: ... @typing.overload def __getitem__(self, s: slice) -> VectorPairStringDouble: """ Retrieve list elements using a slice object """ @typing.overload def __getitem__( self, arg0: typing.SupportsInt | typing.SupportsIndex ) -> tuple[str, float]: ... @typing.overload def __init__(self) -> None: ... @typing.overload def __init__(self, arg0: VectorPairStringDouble) -> None: """ Copy constructor """ @typing.overload def __init__(self, arg0: collections.abc.Iterable) -> None: ... def __iter__(self) -> collections.abc.Iterator[tuple[str, float]]: ... def __len__(self) -> int: ... def __ne__(self, arg0: VectorPairStringDouble) -> bool: ... @typing.overload def __setitem__( self, arg0: typing.SupportsInt | typing.SupportsIndex, arg1: tuple[str, typing.SupportsFloat | typing.SupportsIndex], ) -> None: ... @typing.overload def __setitem__(self, arg0: slice, arg1: VectorPairStringDouble) -> None: """ Assign list elements using a slice object """ def append( self, x: tuple[str, typing.SupportsFloat | typing.SupportsIndex] ) -> None: """ Add an item to the end of the list """ def clear(self) -> None: """ Clear the contents """ def count(self, x: tuple[str, typing.SupportsFloat | typing.SupportsIndex]) -> int: """ Return the number of times ``x`` appears in the list """ @typing.overload def extend(self, L: VectorPairStringDouble) -> None: """ Extend the list by appending all the items in the given list """ @typing.overload def extend(self, L: collections.abc.Iterable) -> None: """ Extend the list by appending all the items in the given list """ def insert( self, i: typing.SupportsInt | typing.SupportsIndex, x: tuple[str, typing.SupportsFloat | typing.SupportsIndex], ) -> None: """ Insert an item at a given position. """ @typing.overload def pop(self) -> tuple[str, float]: """ Remove and return the last item """ @typing.overload def pop(self, i: typing.SupportsInt | typing.SupportsIndex) -> tuple[str, float]: """ Remove and return the item at index ``i`` """ def remove( self, x: tuple[str, typing.SupportsFloat | typing.SupportsIndex] ) -> None: """ Remove the first item from the list whose value is x. It is an error if there is no such item. """ class MapStringComplex: def __bool__(self) -> bool: """ Check whether the map is nonempty """ @typing.overload def __contains__(self, arg0: str) -> bool: ... @typing.overload def __contains__(self, arg0: typing.Any) -> bool: ... def __delitem__(self, arg0: str) -> None: ... def __getitem__(self, arg0: str) -> complex: ... def __init__(self) -> None: ... def __iter__(self) -> collections.abc.Iterator[str]: ... def __len__(self) -> int: ... def __repr__(self) -> str: """ Return the canonical string representation of this map. """ def __setitem__( self, arg0: str, arg1: typing.SupportsComplex | typing.SupportsFloat | typing.SupportsIndex, ) -> None: ... def items(self) -> typing.ItemsView: ... def keys(self) -> typing.KeysView: ... def values(self) -> typing.ValuesView: ... def get_complex_map() -> MapStringComplex: ... def get_vector_of_pairs() -> VectorPairStringDouble: ... typing.pyi000066400000000000000000000004551525537303700400010ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import collections.abc import typing_extensions __all__: list[str] = ["get_buffer", "get_sequence"] def get_buffer(arg0: typing_extensions.Buffer) -> typing_extensions.Buffer: ... def get_sequence(arg0: collections.abc.Sequence) -> collections.abc.Sequence: ... values.pyi000066400000000000000000000014521525537303700377640ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import datetime import numpy from numpy import random __all__: list[str] = [ "Dummy", "Foo", "add_day", "foolist", "foovar", "list_with_none", "none", "random", "t_10ms", "t_20ns", "t_30s", ] class Dummy: linalg = numpy.linalg class Foo: pass def add_day(arg0: datetime.datetime) -> datetime.datetime: ... foolist: list # value = [, ] foovar: Foo # value = list_with_none: list = [None, 2, {}] none = None t_10ms: datetime.timedelta # value = datetime.timedelta(microseconds=10000) t_20ns: datetime.timedelta # value = datetime.timedelta(0) t_30s: datetime.timedelta # value = datetime.timedelta(seconds=30) core.pyi000066400000000000000000000010211525537303700354510ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/numpy-array-wrap-with-annotated/demofrom __future__ import annotations from demo._bindings import ( aliases, classes, eigen, enum, flawed_bindings, functions, hidden_builtins, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) __all__: list[str] = [ "aliases", "classes", "eigen", "enum", "flawed_bindings", "functions", "hidden_builtins", "issues", "methods", "numpy", "properties", "stl", "stl_bind", "typing", "values", ] pure_python/000077500000000000000000000000001525537303700363605ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/numpy-array-wrap-with-annotated/demo__init__.pyi000066400000000000000000000003611525537303700406420ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations from . import classes, functions, functions_3_8_plus, functions_3_9_plus, values __all__: list[str] = [ "classes", "functions", "functions_3_8_plus", "functions_3_9_plus", "values", ] classes.pyi000066400000000000000000000003071525537303700405400ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["A", "B", "C", "X"] class A: """ A """ class B(A): """ B """ class C(B): """ C """ class X: pass functions.pyi000066400000000000000000000015561525537303700411220ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations import sys as sys import typing as typing from demo.pure_python.functions_3_8_plus import args_mix from demo.pure_python.functions_3_9_plus import generic_alias_annotation __all__: list[str] = [ "accept_frozenset", "args_mix", "builtin_function_as_default_arg", "function_as_default_arg", "generic_alias_annotation", "lambda_as_default_arg", "search", "static_method_as_default_arg", "sys", "typing", ] class _Dummy: @staticmethod def foo(): ... def accept_frozenset(arg: frozenset[int | float]) -> int | None: ... def builtin_function_as_default_arg(func: type(len) = len): ... def function_as_default_arg(func: type(search) = search): ... def lambda_as_default_arg(callback=...): ... def search(a: int, b: list[int]) -> int: ... def static_method_as_default_arg(callback=_Dummy.foo): ... functions_3_8_plus.pyi000066400000000000000000000007761525537303700426410ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations import typing as typing __all__: list[str] = [ "Expression", "Token", "args_mix", "nested_current_module_annotations", "typing", ] class Token: pass class Expression: pass def args_mix( a: int, b: float = 0.5, c: str = "", *args: int, x: int = 1, y=int, **kwargs: dict[int, str], ): ... def nested_current_module_annotations( tokens: list[Token], expr: Expression | None = None ) -> dict[str, Expression]: ... functions_3_9_plus.pyi000066400000000000000000000002601525537303700426260ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["generic_alias_annotation"] def generic_alias_annotation(a: list[tuple[int]], b: dict[int, str]) -> list[float]: ... values.pyi000066400000000000000000000001741525537303700404040ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.10/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["callables_dict"] callables_dict: dict = {"len": len, "int": int} pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/000077500000000000000000000000001525537303700226465ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.11/000077500000000000000000000000001525537303700250425ustar00rootroot00000000000000numpy-array-wrap-with-annotated/000077500000000000000000000000001525537303700331425ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.11demo/000077500000000000000000000000001525537303700340665ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.11/numpy-array-wrap-with-annotated__init__.pyi000066400000000000000000000011261525537303700363500ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.11/numpy-array-wrap-with-annotated/demofrom __future__ import annotations from demo._bindings import ( aliases, classes, eigen, enum, flawed_bindings, functions, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) from . import _bindings, core, pure_python __all__: list[str] = [ "aliases", "classes", "core", "eigen", "enum", "flawed_bindings", "functions", "issues", "methods", "numpy", "properties", "pure_python", "stl", "stl_bind", "typing", "values", "version", ] version: str = "0.0.0" _bindings/000077500000000000000000000000001525537303700360225ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.11/numpy-array-wrap-with-annotated/demo__init__.pyi000066400000000000000000000007301525537303700403040ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations from . import ( aliases, classes, eigen, enum, flawed_bindings, functions, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) __all__: list[str] = [ "aliases", "classes", "eigen", "enum", "flawed_bindings", "functions", "issues", "methods", "numpy", "properties", "stl", "stl_bind", "typing", "values", ] aliases/000077500000000000000000000000001525537303700374435ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindings__init__.pyi000066400000000000000000000020761525537303700417320ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import typing import demo._bindings.enum import numpy from demo._bindings.aliases.foreign_method_arg import Bar2 as foreign_type_alias from demo._bindings.aliases.foreign_return import get_foo as foreign_class_alias from numpy import random from . import ( foreign_arg, foreign_attr, foreign_class_member, foreign_method_arg, foreign_method_return, foreign_return, missing_self_arg, ) __all__: list[str] = [ "Color", "Dummy", "foreign_arg", "foreign_attr", "foreign_class_alias", "foreign_class_member", "foreign_enum_default", "foreign_method_arg", "foreign_method_return", "foreign_return", "foreign_type_alias", "func", "local_func_alias", "local_type_alias", "missing_self_arg", "random", ] class Dummy: linalg = numpy.linalg class Color: pass def foreign_enum_default( color: typing.Any = demo._bindings.enum.ConsoleForegroundColor.Blue, ) -> None: ... def func(arg0: int) -> int: ... local_type_alias = Color local_func_alias = func foreign_arg.pyi000066400000000000000000000002371525537303700424520ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["set_foo"] def set_foo(arg0: demo._bindings.classes.Foo) -> int: ... foreign_attr.pyi000066400000000000000000000002631525537303700426520ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["value"] value: demo._bindings.classes.Foo # value = foreign_class_member.pyi000066400000000000000000000003571525537303700443400ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import typing import demo._bindings.classes __all__: list[str] = ["Bar1"] class Bar1: foo: typing.ClassVar[ demo._bindings.classes.Foo ] # value = foreign_method_arg.pyi000066400000000000000000000002621525537303700440100ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar2"] class Bar2: def set_foo(self, arg0: demo._bindings.classes.Foo) -> int: ... foreign_method_return.pyi000066400000000000000000000002651525537303700445610ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar3"] class Bar3: @staticmethod def get_foo() -> demo._bindings.classes.Foo: ... foreign_return.pyi000066400000000000000000000002261525537303700432160ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["get_foo"] def get_foo() -> demo._bindings.classes.Foo: ... missing_self_arg.pyi000066400000000000000000000002541525537303700435020ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar4"] class Bar4: def set_foo(self: demo._bindings.classes.Foo) -> int: ... classes.pyi000066400000000000000000000036571525537303700402150ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "CppException", "Derived", "Foo", "MyBase", "Outer", "ParIter", "ParIterBase", "ParticleContainer", ] class Outer: class Inner: class NestedEnum: """ Members: ONE TWO """ ONE: typing.ClassVar[Outer.Inner.NestedEnum] # value = TWO: typing.ClassVar[Outer.Inner.NestedEnum] # value = __members__: typing.ClassVar[ dict[str, Outer.Inner.NestedEnum] ] # value = {'ONE': , 'TWO': } def __eq__(self, other: typing.Any) -> bool: ... def __getstate__(self) -> int: ... def __hash__(self) -> int: ... def __index__(self) -> int: ... def __init__(self, value: int) -> None: ... def __int__(self) -> int: ... def __ne__(self, other: typing.Any) -> bool: ... def __repr__(self) -> str: ... def __setstate__(self, state: int) -> None: ... def __str__(self) -> str: ... @property def name(self) -> str: ... @property def value(self) -> int: ... value: Outer.Inner.NestedEnum inner: Outer.Inner class MyBase: class Inner: pass name: str class Derived(MyBase): count: int class Foo: class FooChild: def __init__(self) -> None: ... def g(self) -> None: ... def __init__(self) -> None: ... def f(self) -> None: ... class ParIterBase: level: int class ParIter(ParIterBase): def __init__(self, particle_container: ParticleContainer, level: int) -> None: ... class ParticleContainer: name: str Iterator = ParIter def process(self, arg0: ParIter) -> None: ... class CppException(Exception): pass eigen.pyi000066400000000000000000000060031525537303700376330ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing import numpy import scipy.sparse import pybind11_stubgen.typing_ext __all__: list[str] = [ "accept_matrix_int", "accept_vector_float64", "dense_matrix_c", "dense_matrix_r", "fixed_mutator_a", "fixed_mutator_c", "fixed_mutator_r", "four_col_matrix_r", "four_row_matrix_r", "get_matrix_int", "get_vector_float64", "sparse_matrix_c", "sparse_matrix_r", ] def accept_matrix_int( arg0: typing.Annotated[ numpy.ndarray, numpy.int32, pybind11_stubgen.typing_ext.FixedSize(3, 3) ], ) -> None: ... def accept_vector_float64( arg0: typing.Annotated[ numpy.ndarray, numpy.float64, pybind11_stubgen.typing_ext.FixedSize(3, 1) ], ) -> None: ... def dense_matrix_c( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", "n") ], ) -> typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", "n") ]: ... def dense_matrix_r( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", "n") ], ) -> typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", "n") ]: ... def fixed_mutator_a( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.FixedSize(5, 6), numpy.ndarray.flags.writeable, ], ) -> None: ... def fixed_mutator_c( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.FixedSize(5, 6), numpy.ndarray.flags.writeable, numpy.ndarray.flags.f_contiguous, ], ) -> None: ... def fixed_mutator_r( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.FixedSize(5, 6), numpy.ndarray.flags.writeable, numpy.ndarray.flags.c_contiguous, ], ) -> None: ... def four_col_matrix_r( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", 4) ], ) -> typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", 4) ]: ... def four_row_matrix_r( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize(4, "n") ], ) -> typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize(4, "n") ]: ... def get_matrix_int() -> typing.Annotated[ numpy.ndarray, numpy.int32, pybind11_stubgen.typing_ext.FixedSize(3, 3) ]: ... def get_vector_float64() -> typing.Annotated[ numpy.ndarray, numpy.float64, pybind11_stubgen.typing_ext.FixedSize(3, 1) ]: ... def sparse_matrix_c( arg0: typing.Annotated[scipy.sparse.csc_matrix, numpy.float32], ) -> typing.Annotated[scipy.sparse.csc_matrix, numpy.float32]: ... def sparse_matrix_r( arg0: typing.Annotated[scipy.sparse.csr_matrix, numpy.float32], ) -> typing.Annotated[scipy.sparse.csr_matrix, numpy.float32]: ... enum.pyi000066400000000000000000000042501525537303700375120ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "Blue", "ConsoleForegroundColor", "Green", "Magenta", "None_", "Yellow", "accept_defaulted_enum", ] class ConsoleForegroundColor: """ Members: Green Yellow Blue Magenta None_ """ Blue: typing.ClassVar[ ConsoleForegroundColor ] # value = Green: typing.ClassVar[ ConsoleForegroundColor ] # value = Magenta: typing.ClassVar[ ConsoleForegroundColor ] # value = None_: typing.ClassVar[ ConsoleForegroundColor ] # value = Yellow: typing.ClassVar[ ConsoleForegroundColor ] # value = __members__: typing.ClassVar[ dict[str, ConsoleForegroundColor] ] # value = {'Green': , 'Yellow': , 'Blue': , 'Magenta': , 'None_': } def __eq__(self, other: typing.Any) -> bool: ... def __getstate__(self) -> int: ... def __hash__(self) -> int: ... def __index__(self) -> int: ... def __init__(self, value: int) -> None: ... def __int__(self) -> int: ... def __ne__(self, other: typing.Any) -> bool: ... def __repr__(self) -> str: ... def __setstate__(self, state: int) -> None: ... def __str__(self) -> str: ... @property def name(self) -> str: ... @property def value(self) -> int: ... def accept_defaulted_enum( color: ConsoleForegroundColor = ConsoleForegroundColor.None_, ) -> None: ... Blue: ConsoleForegroundColor # value = Green: ConsoleForegroundColor # value = Magenta: ConsoleForegroundColor # value = None_: ConsoleForegroundColor # value = Yellow: ConsoleForegroundColor # value = flawed_bindings.pyi000066400000000000000000000010521525537303700416620ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations __all__: list[str] = [ "Enum", "Unbound", "accept_unbound_enum", "accept_unbound_enum_defaulted", "accept_unbound_type", "accept_unbound_type_defaulted", "get_unbound_type", ] class Unbound: pass class Enum: pass def accept_unbound_enum(arg0: ...) -> int: ... def accept_unbound_enum_defaulted(x: Enum = ...) -> int: ... def accept_unbound_type(arg0: tuple[..., int]) -> int: ... def accept_unbound_type_defaulted(x: Unbound = ...) -> int: ... def get_unbound_type() -> ...: ... functions.pyi000066400000000000000000000043201525537303700405540ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "Foo", "U", "accept_callable", "accept_frozenset", "accept_py_handle", "accept_py_object", "accept_set", "add", "default_custom_arg", "default_int_arg", "default_list_arg", "default_optional_arg", "func_w_anon_args", "func_w_named_pos_args", "generic", "mul", "nested_types", "pass_callback", "passthrough1", "passthrough2", "passthrough3", "passthrough_backwards", "pos_kw_only_mix", "pos_kw_only_variadic_mix", ] class Foo: def __init__(self, arg0: int) -> None: ... def accept_callable(arg0: typing.Callable) -> typing.Any: ... def accept_frozenset(arg0: frozenset) -> None: ... def accept_py_handle(arg0: typing.Any) -> str: ... def accept_py_object(arg0: typing.Any) -> str: ... def accept_set(arg0: set) -> None: ... def add(arg0: int, arg1: int) -> int: ... def default_custom_arg(foo: Foo = Foo(5)) -> None: ... def default_int_arg(n: int = 5) -> None: ... def default_list_arg(l: list = [1, 2, 6, 18]) -> None: ... def default_optional_arg(n: int | None = None) -> None: ... def func_w_anon_args(arg0: int, arg1: int, arg2: int) -> None: ... def func_w_named_pos_args(x: int, y: int, z: int) -> None: ... def generic(*args, **kwargs) -> None: ... @typing.overload def mul(x: int, y: int) -> int: """ Multiply x and y (int) """ @typing.overload def mul(p: float, q: float) -> float: """ Multiply p and q (double) """ def nested_types(arg0: list[Foo] | Foo) -> list[Foo] | Foo: ... def pass_callback(arg0: typing.Callable[[Foo], Foo]) -> Foo: ... def passthrough1(*args, **kwargs): """ passthrough1[T](obj: T) -> T """ @typing.overload def passthrough2() -> None: """ 2. passthrough2[T](obj: T) -> T """ @typing.overload def passthrough3() -> tuple[None, None]: """ 2. passthrough3[T](obj: T) -> tuple[T, None] 3. passthrough3[T1, T2](obj1: T1, obj2: T2) -> tuple[T1, T2] """ def passthrough_backwards(obj: U) -> U: ... def pos_kw_only_mix(i: int, /, j: int, *, k: int) -> tuple: ... def pos_kw_only_variadic_mix(i: int, /, j: int, *args, k: int, **kwargs) -> tuple: ... U: typing.TypeVar # value = ~U issues.pyi000066400000000000000000000021111525537303700400530ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "backslashes_should_be_escaped", "issue_51_catastrophic_regex", "issue_73_utf8_doc_chars", "issue_274_docstring_leading_newline", ] def backslashes_should_be_escaped() -> None: """ \\brief A brief description of this function. A detailed description of this function. Here's some reStructuredText: :math:`x = [x, y, \\theta]^T` """ def issue_274_docstring_leading_newline() -> None: """ This is a docstring """ def issue_51_catastrophic_regex(arg0: int, arg1: int) -> None: """ Use-case: issue_51(os.get_handle_inheritable, os.set_handle_inheritable) """ def issue_73_utf8_doc_chars() -> None: """ Construct a Ramsete unicycle controller. Tuning parameter (b > 0 rad²/m²) for which larger values make convergence more aggressive like a proportional term. Tuning parameter (0 rad⁻¹ < zeta < 1 rad⁻¹) for which larger values provide more damping in response. """ _cleanup: typing.Any # value = methods.pyi000066400000000000000000000003041525537303700402050ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations __all__: list[str] = ["Dummy"] class Dummy: @staticmethod def static_method(arg0: int) -> int: ... def regular_method(self, arg0: int) -> int: ... numpy.pyi000066400000000000000000000011451525537303700377160ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing import numpy __all__: list[str] = [ "accept_ndarray_float64", "accept_ndarray_int", "get_ndarray_float64", "get_ndarray_int", "return_dtype", ] def accept_ndarray_float64( arg0: typing.Annotated[numpy.ndarray, numpy.float64], ) -> None: ... def accept_ndarray_int(arg0: typing.Annotated[numpy.ndarray, numpy.int32]) -> None: ... def get_ndarray_float64() -> typing.Annotated[numpy.ndarray, numpy.float64]: ... def get_ndarray_int() -> typing.Annotated[numpy.ndarray, numpy.int32]: ... def return_dtype() -> numpy.dtype[typing.Any]: ... properties.pyi000066400000000000000000000045521525537303700407470ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "WithGetterSetterDoc", "WithPropAndGetterSetterDoc", "WithPropDoc", "WithoutDoc", ] class WithoutDoc: """ No user docstring provided """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 def_property: int def_readwrite: int @property def def_property_readonly(self) -> int: ... @property def def_readonly(self) -> int: ... class WithPropDoc: """ User docstring provided only to `def_` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 @property def def_property(self) -> int: """ prop doc token """ @def_property.setter def def_property(self, arg1: int) -> None: ... @property def def_property_readonly(self) -> int: """ prop doc token """ @property def def_readonly(self) -> int: """ prop doc token """ @property def def_readwrite(self) -> int: """ prop doc token """ @def_readwrite.setter def def_readwrite(self, arg0: int) -> None: ... class WithGetterSetterDoc: """ User docstring provided via pybind11::cpp_function(..., doc) to getters/setters, but NOT to `def_*(..., doc)` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 @property def def_property(self) -> int: """ getter doc token """ @def_property.setter def def_property(self, arg1: int) -> None: """ setter doc token """ @property def def_property_readonly(self) -> int: """ getter doc token """ class WithPropAndGetterSetterDoc: """ User docstring provided via pybind11::cpp_function(..., doc) to getters/setters and to `def_*(, doc)` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 @property def def_property(self) -> int: """ prop doc token """ @def_property.setter def def_property(self, arg1: int) -> None: ... @property def def_property_readonly(self) -> int: """ prop doc token """ stl.pyi000066400000000000000000000011061525537303700373450ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing import pybind11_stubgen.typing_ext __all__: list[str] = [ "std_array", "std_map", "std_optional", "std_variant", "std_vector", ] def std_array( arg0: typing.Annotated[list[int], pybind11_stubgen.typing_ext.FixedSize(3)], ) -> typing.Annotated[list[int], pybind11_stubgen.typing_ext.FixedSize(3)]: ... def std_map() -> dict[int, complex]: ... def std_optional(arg0: int | None) -> None: ... def std_variant(arg0: int | float | tuple[int, int]) -> None: ... def std_vector() -> list[tuple[int, float]]: ... stl_bind.pyi000066400000000000000000000075741525537303700403600ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "MapStringComplex", "VectorPairStringDouble", "get_complex_map", "get_vector_of_pairs", ] class VectorPairStringDouble: __hash__: typing.ClassVar[None] = None def __bool__(self) -> bool: """ Check whether the list is nonempty """ def __contains__(self, x: tuple[str, float]) -> bool: """ Return true the container contains ``x`` """ @typing.overload def __delitem__(self, arg0: int) -> None: """ Delete the list elements at index ``i`` """ @typing.overload def __delitem__(self, arg0: slice) -> None: """ Delete list elements using a slice object """ def __eq__(self, arg0: VectorPairStringDouble) -> bool: ... @typing.overload def __getitem__(self, s: slice) -> VectorPairStringDouble: """ Retrieve list elements using a slice object """ @typing.overload def __getitem__(self, arg0: int) -> tuple[str, float]: ... @typing.overload def __init__(self) -> None: ... @typing.overload def __init__(self, arg0: VectorPairStringDouble) -> None: """ Copy constructor """ @typing.overload def __init__(self, arg0: typing.Iterable) -> None: ... def __iter__(self) -> typing.Iterator: ... def __len__(self) -> int: ... def __ne__(self, arg0: VectorPairStringDouble) -> bool: ... @typing.overload def __setitem__(self, arg0: int, arg1: tuple[str, float]) -> None: ... @typing.overload def __setitem__(self, arg0: slice, arg1: VectorPairStringDouble) -> None: """ Assign list elements using a slice object """ def append(self, x: tuple[str, float]) -> None: """ Add an item to the end of the list """ def clear(self) -> None: """ Clear the contents """ def count(self, x: tuple[str, float]) -> int: """ Return the number of times ``x`` appears in the list """ @typing.overload def extend(self, L: VectorPairStringDouble) -> None: """ Extend the list by appending all the items in the given list """ @typing.overload def extend(self, L: typing.Iterable) -> None: """ Extend the list by appending all the items in the given list """ def insert(self, i: int, x: tuple[str, float]) -> None: """ Insert an item at a given position. """ @typing.overload def pop(self) -> tuple[str, float]: """ Remove and return the last item """ @typing.overload def pop(self, i: int) -> tuple[str, float]: """ Remove and return the item at index ``i`` """ def remove(self, x: tuple[str, float]) -> None: """ Remove the first item from the list whose value is x. It is an error if there is no such item. """ class MapStringComplex: def __bool__(self) -> bool: """ Check whether the map is nonempty """ @typing.overload def __contains__(self, arg0: str) -> bool: ... @typing.overload def __contains__(self, arg0: typing.Any) -> bool: ... def __delitem__(self, arg0: str) -> None: ... def __getitem__(self, arg0: str) -> complex: ... def __init__(self) -> None: ... def __iter__(self) -> typing.Iterator: ... def __len__(self) -> int: ... def __repr__(self) -> str: """ Return the canonical string representation of this map. """ def __setitem__(self, arg0: str, arg1: complex) -> None: ... def items(self) -> typing.ItemsView[str, complex]: ... def keys(self) -> typing.KeysView[str]: ... def values(self) -> typing.ValuesView[complex]: ... def get_complex_map() -> MapStringComplex: ... def get_vector_of_pairs() -> VectorPairStringDouble: ... typing.pyi000066400000000000000000000004221525537303700400550ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing import typing_extensions __all__: list[str] = ["get_buffer", "get_sequence"] def get_buffer(arg0: typing_extensions.Buffer) -> typing_extensions.Buffer: ... def get_sequence(arg0: typing.Sequence) -> typing.Sequence: ... values.pyi000066400000000000000000000014521525537303700400460ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import datetime import numpy from numpy import random __all__: list[str] = [ "Dummy", "Foo", "add_day", "foolist", "foovar", "list_with_none", "none", "random", "t_10ms", "t_20ns", "t_30s", ] class Dummy: linalg = numpy.linalg class Foo: pass def add_day(arg0: datetime.datetime) -> datetime.datetime: ... foolist: list # value = [, ] foovar: Foo # value = list_with_none: list = [None, 2, {}] none = None t_10ms: datetime.timedelta # value = datetime.timedelta(microseconds=10000) t_20ns: datetime.timedelta # value = datetime.timedelta(0) t_30s: datetime.timedelta # value = datetime.timedelta(seconds=30) core.pyi000066400000000000000000000007451525537303700355470ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.11/numpy-array-wrap-with-annotated/demofrom __future__ import annotations from demo._bindings import ( aliases, classes, eigen, enum, flawed_bindings, functions, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) __all__: list[str] = [ "aliases", "classes", "eigen", "enum", "flawed_bindings", "functions", "issues", "methods", "numpy", "properties", "stl", "stl_bind", "typing", "values", ] pure_python/000077500000000000000000000000001525537303700364425ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.11/numpy-array-wrap-with-annotated/demo__init__.pyi000066400000000000000000000003611525537303700407240ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations from . import classes, functions, functions_3_8_plus, functions_3_9_plus, values __all__: list[str] = [ "classes", "functions", "functions_3_8_plus", "functions_3_9_plus", "values", ] classes.pyi000066400000000000000000000003071525537303700406220ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["A", "B", "C", "X"] class A: """ A """ class B(A): """ B """ class C(B): """ C """ class X: pass functions.pyi000066400000000000000000000015561525537303700412040ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations import sys as sys import typing as typing from demo.pure_python.functions_3_8_plus import args_mix from demo.pure_python.functions_3_9_plus import generic_alias_annotation __all__: list[str] = [ "accept_frozenset", "args_mix", "builtin_function_as_default_arg", "function_as_default_arg", "generic_alias_annotation", "lambda_as_default_arg", "search", "static_method_as_default_arg", "sys", "typing", ] class _Dummy: @staticmethod def foo(): ... def accept_frozenset(arg: frozenset[int | float]) -> int | None: ... def builtin_function_as_default_arg(func: type(len) = len): ... def function_as_default_arg(func: type(search) = search): ... def lambda_as_default_arg(callback=...): ... def search(a: int, b: list[int]) -> int: ... def static_method_as_default_arg(callback=_Dummy.foo): ... functions_3_8_plus.pyi000066400000000000000000000007761525537303700427230ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations import typing as typing __all__: list[str] = [ "Expression", "Token", "args_mix", "nested_current_module_annotations", "typing", ] class Token: pass class Expression: pass def args_mix( a: int, b: float = 0.5, c: str = "", *args: int, x: int = 1, y=int, **kwargs: dict[int, str], ): ... def nested_current_module_annotations( tokens: list[Token], expr: Expression | None = None ) -> dict[str, Expression]: ... functions_3_9_plus.pyi000066400000000000000000000002601525537303700427100ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["generic_alias_annotation"] def generic_alias_annotation(a: list[tuple[int]], b: dict[int, str]) -> list[float]: ... values.pyi000066400000000000000000000001741525537303700404660ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["callables_dict"] callables_dict: dict = {"len": len, "int": int} pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.12/000077500000000000000000000000001525537303700250435ustar00rootroot00000000000000numpy-array-wrap-with-annotated/000077500000000000000000000000001525537303700331435ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.12demo/000077500000000000000000000000001525537303700340675ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.12/numpy-array-wrap-with-annotated__init__.pyi000066400000000000000000000011261525537303700363510ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.12/numpy-array-wrap-with-annotated/demofrom __future__ import annotations from demo._bindings import ( aliases, classes, eigen, enum, flawed_bindings, functions, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) from . import _bindings, core, pure_python __all__: list[str] = [ "aliases", "classes", "core", "eigen", "enum", "flawed_bindings", "functions", "issues", "methods", "numpy", "properties", "pure_python", "stl", "stl_bind", "typing", "values", "version", ] version: str = "0.0.0" _bindings/000077500000000000000000000000001525537303700360235ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.12/numpy-array-wrap-with-annotated/demo__init__.pyi000066400000000000000000000007301525537303700403050ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations from . import ( aliases, classes, eigen, enum, flawed_bindings, functions, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) __all__: list[str] = [ "aliases", "classes", "eigen", "enum", "flawed_bindings", "functions", "issues", "methods", "numpy", "properties", "stl", "stl_bind", "typing", "values", ] aliases/000077500000000000000000000000001525537303700374445ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindings__init__.pyi000066400000000000000000000020761525537303700417330ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import typing import demo._bindings.enum import numpy from demo._bindings.aliases.foreign_method_arg import Bar2 as foreign_type_alias from demo._bindings.aliases.foreign_return import get_foo as foreign_class_alias from numpy import random from . import ( foreign_arg, foreign_attr, foreign_class_member, foreign_method_arg, foreign_method_return, foreign_return, missing_self_arg, ) __all__: list[str] = [ "Color", "Dummy", "foreign_arg", "foreign_attr", "foreign_class_alias", "foreign_class_member", "foreign_enum_default", "foreign_method_arg", "foreign_method_return", "foreign_return", "foreign_type_alias", "func", "local_func_alias", "local_type_alias", "missing_self_arg", "random", ] class Dummy: linalg = numpy.linalg class Color: pass def foreign_enum_default( color: typing.Any = demo._bindings.enum.ConsoleForegroundColor.Blue, ) -> None: ... def func(arg0: int) -> int: ... local_type_alias = Color local_func_alias = func foreign_arg.pyi000066400000000000000000000002371525537303700424530ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["set_foo"] def set_foo(arg0: demo._bindings.classes.Foo) -> int: ... foreign_attr.pyi000066400000000000000000000002631525537303700426530ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["value"] value: demo._bindings.classes.Foo # value = foreign_class_member.pyi000066400000000000000000000003571525537303700443410ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import typing import demo._bindings.classes __all__: list[str] = ["Bar1"] class Bar1: foo: typing.ClassVar[ demo._bindings.classes.Foo ] # value = foreign_method_arg.pyi000066400000000000000000000002621525537303700440110ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar2"] class Bar2: def set_foo(self, arg0: demo._bindings.classes.Foo) -> int: ... foreign_method_return.pyi000066400000000000000000000002651525537303700445620ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar3"] class Bar3: @staticmethod def get_foo() -> demo._bindings.classes.Foo: ... foreign_return.pyi000066400000000000000000000002261525537303700432170ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["get_foo"] def get_foo() -> demo._bindings.classes.Foo: ... missing_self_arg.pyi000066400000000000000000000002541525537303700435030ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar4"] class Bar4: def set_foo(self: demo._bindings.classes.Foo) -> int: ... classes.pyi000066400000000000000000000036571525537303700402160ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "CppException", "Derived", "Foo", "MyBase", "Outer", "ParIter", "ParIterBase", "ParticleContainer", ] class Outer: class Inner: class NestedEnum: """ Members: ONE TWO """ ONE: typing.ClassVar[Outer.Inner.NestedEnum] # value = TWO: typing.ClassVar[Outer.Inner.NestedEnum] # value = __members__: typing.ClassVar[ dict[str, Outer.Inner.NestedEnum] ] # value = {'ONE': , 'TWO': } def __eq__(self, other: typing.Any) -> bool: ... def __getstate__(self) -> int: ... def __hash__(self) -> int: ... def __index__(self) -> int: ... def __init__(self, value: int) -> None: ... def __int__(self) -> int: ... def __ne__(self, other: typing.Any) -> bool: ... def __repr__(self) -> str: ... def __setstate__(self, state: int) -> None: ... def __str__(self) -> str: ... @property def name(self) -> str: ... @property def value(self) -> int: ... value: Outer.Inner.NestedEnum inner: Outer.Inner class MyBase: class Inner: pass name: str class Derived(MyBase): count: int class Foo: class FooChild: def __init__(self) -> None: ... def g(self) -> None: ... def __init__(self) -> None: ... def f(self) -> None: ... class ParIterBase: level: int class ParIter(ParIterBase): def __init__(self, particle_container: ParticleContainer, level: int) -> None: ... class ParticleContainer: name: str Iterator = ParIter def process(self, arg0: ParIter) -> None: ... class CppException(Exception): pass eigen.pyi000066400000000000000000000060031525537303700376340ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing import numpy import scipy.sparse import pybind11_stubgen.typing_ext __all__: list[str] = [ "accept_matrix_int", "accept_vector_float64", "dense_matrix_c", "dense_matrix_r", "fixed_mutator_a", "fixed_mutator_c", "fixed_mutator_r", "four_col_matrix_r", "four_row_matrix_r", "get_matrix_int", "get_vector_float64", "sparse_matrix_c", "sparse_matrix_r", ] def accept_matrix_int( arg0: typing.Annotated[ numpy.ndarray, numpy.int32, pybind11_stubgen.typing_ext.FixedSize(3, 3) ], ) -> None: ... def accept_vector_float64( arg0: typing.Annotated[ numpy.ndarray, numpy.float64, pybind11_stubgen.typing_ext.FixedSize(3, 1) ], ) -> None: ... def dense_matrix_c( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", "n") ], ) -> typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", "n") ]: ... def dense_matrix_r( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", "n") ], ) -> typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", "n") ]: ... def fixed_mutator_a( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.FixedSize(5, 6), numpy.ndarray.flags.writeable, ], ) -> None: ... def fixed_mutator_c( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.FixedSize(5, 6), numpy.ndarray.flags.writeable, numpy.ndarray.flags.f_contiguous, ], ) -> None: ... def fixed_mutator_r( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.FixedSize(5, 6), numpy.ndarray.flags.writeable, numpy.ndarray.flags.c_contiguous, ], ) -> None: ... def four_col_matrix_r( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", 4) ], ) -> typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", 4) ]: ... def four_row_matrix_r( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize(4, "n") ], ) -> typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize(4, "n") ]: ... def get_matrix_int() -> typing.Annotated[ numpy.ndarray, numpy.int32, pybind11_stubgen.typing_ext.FixedSize(3, 3) ]: ... def get_vector_float64() -> typing.Annotated[ numpy.ndarray, numpy.float64, pybind11_stubgen.typing_ext.FixedSize(3, 1) ]: ... def sparse_matrix_c( arg0: typing.Annotated[scipy.sparse.csc_matrix, numpy.float32], ) -> typing.Annotated[scipy.sparse.csc_matrix, numpy.float32]: ... def sparse_matrix_r( arg0: typing.Annotated[scipy.sparse.csr_matrix, numpy.float32], ) -> typing.Annotated[scipy.sparse.csr_matrix, numpy.float32]: ... enum.pyi000066400000000000000000000042501525537303700375130ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "Blue", "ConsoleForegroundColor", "Green", "Magenta", "None_", "Yellow", "accept_defaulted_enum", ] class ConsoleForegroundColor: """ Members: Green Yellow Blue Magenta None_ """ Blue: typing.ClassVar[ ConsoleForegroundColor ] # value = Green: typing.ClassVar[ ConsoleForegroundColor ] # value = Magenta: typing.ClassVar[ ConsoleForegroundColor ] # value = None_: typing.ClassVar[ ConsoleForegroundColor ] # value = Yellow: typing.ClassVar[ ConsoleForegroundColor ] # value = __members__: typing.ClassVar[ dict[str, ConsoleForegroundColor] ] # value = {'Green': , 'Yellow': , 'Blue': , 'Magenta': , 'None_': } def __eq__(self, other: typing.Any) -> bool: ... def __getstate__(self) -> int: ... def __hash__(self) -> int: ... def __index__(self) -> int: ... def __init__(self, value: int) -> None: ... def __int__(self) -> int: ... def __ne__(self, other: typing.Any) -> bool: ... def __repr__(self) -> str: ... def __setstate__(self, state: int) -> None: ... def __str__(self) -> str: ... @property def name(self) -> str: ... @property def value(self) -> int: ... def accept_defaulted_enum( color: ConsoleForegroundColor = ConsoleForegroundColor.None_, ) -> None: ... Blue: ConsoleForegroundColor # value = Green: ConsoleForegroundColor # value = Magenta: ConsoleForegroundColor # value = None_: ConsoleForegroundColor # value = Yellow: ConsoleForegroundColor # value = flawed_bindings.pyi000066400000000000000000000010521525537303700416630ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations __all__: list[str] = [ "Enum", "Unbound", "accept_unbound_enum", "accept_unbound_enum_defaulted", "accept_unbound_type", "accept_unbound_type_defaulted", "get_unbound_type", ] class Unbound: pass class Enum: pass def accept_unbound_enum(arg0: ...) -> int: ... def accept_unbound_enum_defaulted(x: Enum = ...) -> int: ... def accept_unbound_type(arg0: tuple[..., int]) -> int: ... def accept_unbound_type_defaulted(x: Unbound = ...) -> int: ... def get_unbound_type() -> ...: ... functions.pyi000066400000000000000000000045121525537303700405600ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "Foo", "U", "accept_annotated_callable", "accept_callable", "accept_frozenset", "accept_py_handle", "accept_py_object", "accept_set", "add", "default_custom_arg", "default_int_arg", "default_list_arg", "default_optional_arg", "func_w_anon_args", "func_w_named_pos_args", "generic", "mul", "nested_types", "pass_callback", "passthrough1", "passthrough2", "passthrough3", "passthrough_backwards", "pos_kw_only_mix", "pos_kw_only_variadic_mix", ] class Foo: def __init__(self, arg0: int) -> None: ... def accept_annotated_callable(arg0: typing.Callable[[int, int], int]) -> typing.Any: ... def accept_callable(arg0: typing.Callable) -> typing.Any: ... def accept_frozenset(arg0: frozenset) -> None: ... def accept_py_handle(arg0: typing.Any) -> str: ... def accept_py_object(arg0: typing.Any) -> str: ... def accept_set(arg0: set) -> None: ... def add(arg0: int, arg1: int) -> int: ... def default_custom_arg(foo: Foo = Foo(5)) -> None: ... def default_int_arg(n: int = 5) -> None: ... def default_list_arg(l: list = [1, 2, 6, 18]) -> None: ... def default_optional_arg(n: int | None = None) -> None: ... def func_w_anon_args(arg0: int, arg1: int, arg2: int) -> None: ... def func_w_named_pos_args(x: int, y: int, z: int) -> None: ... def generic(*args, **kwargs) -> None: ... @typing.overload def mul(x: int, y: int) -> int: """ Multiply x and y (int) """ @typing.overload def mul(p: float, q: float) -> float: """ Multiply p and q (double) """ def nested_types(arg0: list[Foo] | Foo) -> list[Foo] | Foo: ... def pass_callback(arg0: typing.Callable[[Foo], Foo]) -> Foo: ... def passthrough1(*args, **kwargs): """ passthrough1[T](obj: T) -> T """ @typing.overload def passthrough2() -> None: """ 2. passthrough2[T](obj: T) -> T """ @typing.overload def passthrough3() -> tuple[None, None]: """ 2. passthrough3[T](obj: T) -> tuple[T, None] 3. passthrough3[T1, T2](obj1: T1, obj2: T2) -> tuple[T1, T2] """ def passthrough_backwards(obj: U) -> U: ... def pos_kw_only_mix(i: int, /, j: int, *, k: int) -> tuple: ... def pos_kw_only_variadic_mix(i: int, /, j: int, *args, k: int, **kwargs) -> tuple: ... U: typing.TypeVar # value = ~U issues.pyi000066400000000000000000000021111525537303700400540ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "backslashes_should_be_escaped", "issue_51_catastrophic_regex", "issue_73_utf8_doc_chars", "issue_274_docstring_leading_newline", ] def backslashes_should_be_escaped() -> None: """ \\brief A brief description of this function. A detailed description of this function. Here's some reStructuredText: :math:`x = [x, y, \\theta]^T` """ def issue_274_docstring_leading_newline() -> None: """ This is a docstring """ def issue_51_catastrophic_regex(arg0: int, arg1: int) -> None: """ Use-case: issue_51(os.get_handle_inheritable, os.set_handle_inheritable) """ def issue_73_utf8_doc_chars() -> None: """ Construct a Ramsete unicycle controller. Tuning parameter (b > 0 rad²/m²) for which larger values make convergence more aggressive like a proportional term. Tuning parameter (0 rad⁻¹ < zeta < 1 rad⁻¹) for which larger values provide more damping in response. """ _cleanup: typing.Any # value = methods.pyi000066400000000000000000000003041525537303700402060ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations __all__: list[str] = ["Dummy"] class Dummy: @staticmethod def static_method(arg0: int) -> int: ... def regular_method(self, arg0: int) -> int: ... numpy.pyi000066400000000000000000000011451525537303700377170ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing import numpy __all__: list[str] = [ "accept_ndarray_float64", "accept_ndarray_int", "get_ndarray_float64", "get_ndarray_int", "return_dtype", ] def accept_ndarray_float64( arg0: typing.Annotated[numpy.ndarray, numpy.float64], ) -> None: ... def accept_ndarray_int(arg0: typing.Annotated[numpy.ndarray, numpy.int32]) -> None: ... def get_ndarray_float64() -> typing.Annotated[numpy.ndarray, numpy.float64]: ... def get_ndarray_int() -> typing.Annotated[numpy.ndarray, numpy.int32]: ... def return_dtype() -> numpy.dtype[typing.Any]: ... properties.pyi000066400000000000000000000045521525537303700407500ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "WithGetterSetterDoc", "WithPropAndGetterSetterDoc", "WithPropDoc", "WithoutDoc", ] class WithoutDoc: """ No user docstring provided """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 def_property: int def_readwrite: int @property def def_property_readonly(self) -> int: ... @property def def_readonly(self) -> int: ... class WithPropDoc: """ User docstring provided only to `def_` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 @property def def_property(self) -> int: """ prop doc token """ @def_property.setter def def_property(self, arg1: int) -> None: ... @property def def_property_readonly(self) -> int: """ prop doc token """ @property def def_readonly(self) -> int: """ prop doc token """ @property def def_readwrite(self) -> int: """ prop doc token """ @def_readwrite.setter def def_readwrite(self, arg0: int) -> None: ... class WithGetterSetterDoc: """ User docstring provided via pybind11::cpp_function(..., doc) to getters/setters, but NOT to `def_*(..., doc)` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 @property def def_property(self) -> int: """ getter doc token """ @def_property.setter def def_property(self, arg1: int) -> None: """ setter doc token """ @property def def_property_readonly(self) -> int: """ getter doc token """ class WithPropAndGetterSetterDoc: """ User docstring provided via pybind11::cpp_function(..., doc) to getters/setters and to `def_*(, doc)` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 @property def def_property(self) -> int: """ prop doc token """ @def_property.setter def def_property(self, arg1: int) -> None: ... @property def def_property_readonly(self) -> int: """ prop doc token """ stl.pyi000066400000000000000000000011061525537303700373460ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing import pybind11_stubgen.typing_ext __all__: list[str] = [ "std_array", "std_map", "std_optional", "std_variant", "std_vector", ] def std_array( arg0: typing.Annotated[list[int], pybind11_stubgen.typing_ext.FixedSize(3)], ) -> typing.Annotated[list[int], pybind11_stubgen.typing_ext.FixedSize(3)]: ... def std_map() -> dict[int, complex]: ... def std_optional(arg0: int | None) -> None: ... def std_variant(arg0: int | float | tuple[int, int]) -> None: ... def std_vector() -> list[tuple[int, float]]: ... stl_bind.pyi000066400000000000000000000075701525537303700403550ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "MapStringComplex", "VectorPairStringDouble", "get_complex_map", "get_vector_of_pairs", ] class VectorPairStringDouble: __hash__: typing.ClassVar[None] = None def __bool__(self) -> bool: """ Check whether the list is nonempty """ def __contains__(self, x: tuple[str, float]) -> bool: """ Return true the container contains ``x`` """ @typing.overload def __delitem__(self, arg0: int) -> None: """ Delete the list elements at index ``i`` """ @typing.overload def __delitem__(self, arg0: slice) -> None: """ Delete list elements using a slice object """ def __eq__(self, arg0: VectorPairStringDouble) -> bool: ... @typing.overload def __getitem__(self, s: slice) -> VectorPairStringDouble: """ Retrieve list elements using a slice object """ @typing.overload def __getitem__(self, arg0: int) -> tuple[str, float]: ... @typing.overload def __init__(self) -> None: ... @typing.overload def __init__(self, arg0: VectorPairStringDouble) -> None: """ Copy constructor """ @typing.overload def __init__(self, arg0: typing.Iterable) -> None: ... def __iter__(self) -> typing.Iterator[tuple[str, float]]: ... def __len__(self) -> int: ... def __ne__(self, arg0: VectorPairStringDouble) -> bool: ... @typing.overload def __setitem__(self, arg0: int, arg1: tuple[str, float]) -> None: ... @typing.overload def __setitem__(self, arg0: slice, arg1: VectorPairStringDouble) -> None: """ Assign list elements using a slice object """ def append(self, x: tuple[str, float]) -> None: """ Add an item to the end of the list """ def clear(self) -> None: """ Clear the contents """ def count(self, x: tuple[str, float]) -> int: """ Return the number of times ``x`` appears in the list """ @typing.overload def extend(self, L: VectorPairStringDouble) -> None: """ Extend the list by appending all the items in the given list """ @typing.overload def extend(self, L: typing.Iterable) -> None: """ Extend the list by appending all the items in the given list """ def insert(self, i: int, x: tuple[str, float]) -> None: """ Insert an item at a given position. """ @typing.overload def pop(self) -> tuple[str, float]: """ Remove and return the last item """ @typing.overload def pop(self, i: int) -> tuple[str, float]: """ Remove and return the item at index ``i`` """ def remove(self, x: tuple[str, float]) -> None: """ Remove the first item from the list whose value is x. It is an error if there is no such item. """ class MapStringComplex: def __bool__(self) -> bool: """ Check whether the map is nonempty """ @typing.overload def __contains__(self, arg0: str) -> bool: ... @typing.overload def __contains__(self, arg0: typing.Any) -> bool: ... def __delitem__(self, arg0: str) -> None: ... def __getitem__(self, arg0: str) -> complex: ... def __init__(self) -> None: ... def __iter__(self) -> typing.Iterator[str]: ... def __len__(self) -> int: ... def __repr__(self) -> str: """ Return the canonical string representation of this map. """ def __setitem__(self, arg0: str, arg1: complex) -> None: ... def items(self) -> typing.ItemsView: ... def keys(self) -> typing.KeysView: ... def values(self) -> typing.ValuesView: ... def get_complex_map() -> MapStringComplex: ... def get_vector_of_pairs() -> VectorPairStringDouble: ... typing.pyi000066400000000000000000000004221525537303700400560ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing import typing_extensions __all__: list[str] = ["get_buffer", "get_sequence"] def get_buffer(arg0: typing_extensions.Buffer) -> typing_extensions.Buffer: ... def get_sequence(arg0: typing.Sequence) -> typing.Sequence: ... values.pyi000066400000000000000000000014521525537303700400470ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import datetime import numpy from numpy import random __all__: list[str] = [ "Dummy", "Foo", "add_day", "foolist", "foovar", "list_with_none", "none", "random", "t_10ms", "t_20ns", "t_30s", ] class Dummy: linalg = numpy.linalg class Foo: pass def add_day(arg0: datetime.datetime) -> datetime.datetime: ... foolist: list # value = [, ] foovar: Foo # value = list_with_none: list = [None, 2, {}] none = None t_10ms: datetime.timedelta # value = datetime.timedelta(microseconds=10000) t_20ns: datetime.timedelta # value = datetime.timedelta(0) t_30s: datetime.timedelta # value = datetime.timedelta(seconds=30) core.pyi000066400000000000000000000007451525537303700355500ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.12/numpy-array-wrap-with-annotated/demofrom __future__ import annotations from demo._bindings import ( aliases, classes, eigen, enum, flawed_bindings, functions, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) __all__: list[str] = [ "aliases", "classes", "eigen", "enum", "flawed_bindings", "functions", "issues", "methods", "numpy", "properties", "stl", "stl_bind", "typing", "values", ] pure_python/000077500000000000000000000000001525537303700364435ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.12/numpy-array-wrap-with-annotated/demo__init__.pyi000066400000000000000000000003611525537303700407250ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations from . import classes, functions, functions_3_8_plus, functions_3_9_plus, values __all__: list[str] = [ "classes", "functions", "functions_3_8_plus", "functions_3_9_plus", "values", ] classes.pyi000066400000000000000000000003071525537303700406230ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["A", "B", "C", "X"] class A: """ A """ class B(A): """ B """ class C(B): """ C """ class X: pass functions.pyi000066400000000000000000000015561525537303700412050ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations import sys as sys import typing as typing from demo.pure_python.functions_3_8_plus import args_mix from demo.pure_python.functions_3_9_plus import generic_alias_annotation __all__: list[str] = [ "accept_frozenset", "args_mix", "builtin_function_as_default_arg", "function_as_default_arg", "generic_alias_annotation", "lambda_as_default_arg", "search", "static_method_as_default_arg", "sys", "typing", ] class _Dummy: @staticmethod def foo(): ... def accept_frozenset(arg: frozenset[int | float]) -> int | None: ... def builtin_function_as_default_arg(func: type(len) = len): ... def function_as_default_arg(func: type(search) = search): ... def lambda_as_default_arg(callback=...): ... def search(a: int, b: list[int]) -> int: ... def static_method_as_default_arg(callback=_Dummy.foo): ... functions_3_8_plus.pyi000066400000000000000000000007761525537303700427240ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations import typing as typing __all__: list[str] = [ "Expression", "Token", "args_mix", "nested_current_module_annotations", "typing", ] class Token: pass class Expression: pass def args_mix( a: int, b: float = 0.5, c: str = "", *args: int, x: int = 1, y=int, **kwargs: dict[int, str], ): ... def nested_current_module_annotations( tokens: list[Token], expr: Expression | None = None ) -> dict[str, Expression]: ... functions_3_9_plus.pyi000066400000000000000000000002601525537303700427110ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["generic_alias_annotation"] def generic_alias_annotation(a: list[tuple[int]], b: dict[int, str]) -> list[float]: ... values.pyi000066400000000000000000000001741525537303700404670ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["callables_dict"] callables_dict: dict = {"len": len, "int": int} pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/000077500000000000000000000000001525537303700250445ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-use-type-var/000077500000000000000000000000001525537303700316675ustar00rootroot00000000000000demo/000077500000000000000000000000001525537303700325345ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-use-type-var__init__.pyi000066400000000000000000000011261525537303700350160ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-use-type-var/demofrom __future__ import annotations from demo._bindings import ( aliases, classes, eigen, enum, flawed_bindings, functions, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) from . import _bindings, core, pure_python __all__: list[str] = [ "aliases", "classes", "core", "eigen", "enum", "flawed_bindings", "functions", "issues", "methods", "numpy", "properties", "pure_python", "stl", "stl_bind", "typing", "values", "version", ] version: str = "0.0.0" _bindings/000077500000000000000000000000001525537303700344705ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-use-type-var/demo__init__.pyi000066400000000000000000000007301525537303700367520ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations from . import ( aliases, classes, eigen, enum, flawed_bindings, functions, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) __all__: list[str] = [ "aliases", "classes", "eigen", "enum", "flawed_bindings", "functions", "issues", "methods", "numpy", "properties", "stl", "stl_bind", "typing", "values", ] aliases/000077500000000000000000000000001525537303700361115ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-use-type-var/demo/_bindings__init__.pyi000066400000000000000000000020761525537303700404000ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-use-type-var/demo/_bindings/aliasesfrom __future__ import annotations import typing import demo._bindings.enum import numpy from demo._bindings.aliases.foreign_method_arg import Bar2 as foreign_type_alias from demo._bindings.aliases.foreign_return import get_foo as foreign_class_alias from numpy import random from . import ( foreign_arg, foreign_attr, foreign_class_member, foreign_method_arg, foreign_method_return, foreign_return, missing_self_arg, ) __all__: list[str] = [ "Color", "Dummy", "foreign_arg", "foreign_attr", "foreign_class_alias", "foreign_class_member", "foreign_enum_default", "foreign_method_arg", "foreign_method_return", "foreign_return", "foreign_type_alias", "func", "local_func_alias", "local_type_alias", "missing_self_arg", "random", ] class Dummy: linalg = numpy.linalg class Color: pass def foreign_enum_default( color: typing.Any = demo._bindings.enum.ConsoleForegroundColor.Blue, ) -> None: ... def func(arg0: int) -> int: ... local_type_alias = Color local_func_alias = func foreign_arg.pyi000066400000000000000000000002371525537303700411200ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-use-type-var/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["set_foo"] def set_foo(arg0: demo._bindings.classes.Foo) -> int: ... foreign_attr.pyi000066400000000000000000000002631525537303700413200ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-use-type-var/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["value"] value: demo._bindings.classes.Foo # value = foreign_class_member.pyi000066400000000000000000000003571525537303700430060ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-use-type-var/demo/_bindings/aliasesfrom __future__ import annotations import typing import demo._bindings.classes __all__: list[str] = ["Bar1"] class Bar1: foo: typing.ClassVar[ demo._bindings.classes.Foo ] # value = foreign_method_arg.pyi000066400000000000000000000002621525537303700424560ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-use-type-var/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar2"] class Bar2: def set_foo(self, arg0: demo._bindings.classes.Foo) -> int: ... foreign_method_return.pyi000066400000000000000000000002651525537303700432270ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-use-type-var/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar3"] class Bar3: @staticmethod def get_foo() -> demo._bindings.classes.Foo: ... foreign_return.pyi000066400000000000000000000002261525537303700416640ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-use-type-var/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["get_foo"] def get_foo() -> demo._bindings.classes.Foo: ... missing_self_arg.pyi000066400000000000000000000002541525537303700421500ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-use-type-var/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar4"] class Bar4: def set_foo(self: demo._bindings.classes.Foo) -> int: ... classes.pyi000066400000000000000000000036571525537303700366630ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "CppException", "Derived", "Foo", "MyBase", "Outer", "ParIter", "ParIterBase", "ParticleContainer", ] class Outer: class Inner: class NestedEnum: """ Members: ONE TWO """ ONE: typing.ClassVar[Outer.Inner.NestedEnum] # value = TWO: typing.ClassVar[Outer.Inner.NestedEnum] # value = __members__: typing.ClassVar[ dict[str, Outer.Inner.NestedEnum] ] # value = {'ONE': , 'TWO': } def __eq__(self, other: typing.Any) -> bool: ... def __getstate__(self) -> int: ... def __hash__(self) -> int: ... def __index__(self) -> int: ... def __init__(self, value: int) -> None: ... def __int__(self) -> int: ... def __ne__(self, other: typing.Any) -> bool: ... def __repr__(self) -> str: ... def __setstate__(self, state: int) -> None: ... def __str__(self) -> str: ... @property def name(self) -> str: ... @property def value(self) -> int: ... value: Outer.Inner.NestedEnum inner: Outer.Inner class MyBase: class Inner: pass name: str class Derived(MyBase): count: int class Foo: class FooChild: def __init__(self) -> None: ... def g(self) -> None: ... def __init__(self) -> None: ... def f(self) -> None: ... class ParIterBase: level: int class ParIter(ParIterBase): def __init__(self, particle_container: ParticleContainer, level: int) -> None: ... class ParticleContainer: name: str Iterator = ParIter def process(self, arg0: ParIter) -> None: ... class CppException(Exception): pass eigen.pyi000066400000000000000000000044241525537303700363060ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import typing import numpy import scipy.sparse __all__: list[str] = [ "accept_matrix_int", "accept_vector_float64", "dense_matrix_c", "dense_matrix_r", "fixed_mutator_a", "fixed_mutator_c", "fixed_mutator_r", "four_col_matrix_r", "four_row_matrix_r", "get_matrix_int", "get_vector_float64", "sparse_matrix_c", "sparse_matrix_r", ] M = typing.TypeVar("M", bound=int) N = typing.TypeVar("N", bound=int) def accept_matrix_int( arg0: numpy.ndarray[ tuple[typing.Literal[3], typing.Literal[3]], numpy.dtype[numpy.int32] ], ) -> None: ... def accept_vector_float64( arg0: numpy.ndarray[ tuple[typing.Literal[3], typing.Literal[1]], numpy.dtype[numpy.float64] ], ) -> None: ... def dense_matrix_c( arg0: numpy.ndarray[tuple[M, N], numpy.dtype[numpy.float32]], ) -> numpy.ndarray[tuple[M, N], numpy.dtype[numpy.float32]]: ... def dense_matrix_r( arg0: numpy.ndarray[tuple[M, N], numpy.dtype[numpy.float32]], ) -> numpy.ndarray[tuple[M, N], numpy.dtype[numpy.float32]]: ... def fixed_mutator_a( arg0: numpy.ndarray[ tuple[typing.Literal[5], typing.Literal[6]], numpy.dtype[numpy.float32] ], ) -> None: ... def fixed_mutator_c( arg0: numpy.ndarray[ tuple[typing.Literal[5], typing.Literal[6]], numpy.dtype[numpy.float32] ], ) -> None: ... def fixed_mutator_r( arg0: numpy.ndarray[ tuple[typing.Literal[5], typing.Literal[6]], numpy.dtype[numpy.float32] ], ) -> None: ... def four_col_matrix_r( arg0: numpy.ndarray[tuple[M, typing.Literal[4]], numpy.dtype[numpy.float32]], ) -> numpy.ndarray[tuple[M, typing.Literal[4]], numpy.dtype[numpy.float32]]: ... def four_row_matrix_r( arg0: numpy.ndarray[tuple[typing.Literal[4], N], numpy.dtype[numpy.float32]], ) -> numpy.ndarray[tuple[typing.Literal[4], N], numpy.dtype[numpy.float32]]: ... def get_matrix_int() -> numpy.ndarray[ tuple[typing.Literal[3], typing.Literal[3]], numpy.dtype[numpy.int32] ]: ... def get_vector_float64() -> numpy.ndarray[ tuple[typing.Literal[3], typing.Literal[1]], numpy.dtype[numpy.float64] ]: ... def sparse_matrix_c(arg0: scipy.sparse.csc_matrix) -> scipy.sparse.csc_matrix: ... def sparse_matrix_r(arg0: scipy.sparse.csr_matrix) -> scipy.sparse.csr_matrix: ... enum.pyi000066400000000000000000000042501525537303700361600ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "Blue", "ConsoleForegroundColor", "Green", "Magenta", "None_", "Yellow", "accept_defaulted_enum", ] class ConsoleForegroundColor: """ Members: Green Yellow Blue Magenta None_ """ Blue: typing.ClassVar[ ConsoleForegroundColor ] # value = Green: typing.ClassVar[ ConsoleForegroundColor ] # value = Magenta: typing.ClassVar[ ConsoleForegroundColor ] # value = None_: typing.ClassVar[ ConsoleForegroundColor ] # value = Yellow: typing.ClassVar[ ConsoleForegroundColor ] # value = __members__: typing.ClassVar[ dict[str, ConsoleForegroundColor] ] # value = {'Green': , 'Yellow': , 'Blue': , 'Magenta': , 'None_': } def __eq__(self, other: typing.Any) -> bool: ... def __getstate__(self) -> int: ... def __hash__(self) -> int: ... def __index__(self) -> int: ... def __init__(self, value: int) -> None: ... def __int__(self) -> int: ... def __ne__(self, other: typing.Any) -> bool: ... def __repr__(self) -> str: ... def __setstate__(self, state: int) -> None: ... def __str__(self) -> str: ... @property def name(self) -> str: ... @property def value(self) -> int: ... def accept_defaulted_enum( color: ConsoleForegroundColor = ConsoleForegroundColor.None_, ) -> None: ... Blue: ConsoleForegroundColor # value = Green: ConsoleForegroundColor # value = Magenta: ConsoleForegroundColor # value = None_: ConsoleForegroundColor # value = Yellow: ConsoleForegroundColor # value = flawed_bindings.pyi000066400000000000000000000010521525537303700403300ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations __all__: list[str] = [ "Enum", "Unbound", "accept_unbound_enum", "accept_unbound_enum_defaulted", "accept_unbound_type", "accept_unbound_type_defaulted", "get_unbound_type", ] class Unbound: pass class Enum: pass def accept_unbound_enum(arg0: ...) -> int: ... def accept_unbound_enum_defaulted(x: Enum = ...) -> int: ... def accept_unbound_type(arg0: tuple[..., int]) -> int: ... def accept_unbound_type_defaulted(x: Unbound = ...) -> int: ... def get_unbound_type() -> ...: ... functions.pyi000066400000000000000000000045121525537303700372250ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "Foo", "U", "accept_annotated_callable", "accept_callable", "accept_frozenset", "accept_py_handle", "accept_py_object", "accept_set", "add", "default_custom_arg", "default_int_arg", "default_list_arg", "default_optional_arg", "func_w_anon_args", "func_w_named_pos_args", "generic", "mul", "nested_types", "pass_callback", "passthrough1", "passthrough2", "passthrough3", "passthrough_backwards", "pos_kw_only_mix", "pos_kw_only_variadic_mix", ] class Foo: def __init__(self, arg0: int) -> None: ... def accept_annotated_callable(arg0: typing.Callable[[int, int], int]) -> typing.Any: ... def accept_callable(arg0: typing.Callable) -> typing.Any: ... def accept_frozenset(arg0: frozenset) -> None: ... def accept_py_handle(arg0: typing.Any) -> str: ... def accept_py_object(arg0: typing.Any) -> str: ... def accept_set(arg0: set) -> None: ... def add(arg0: int, arg1: int) -> int: ... def default_custom_arg(foo: Foo = Foo(5)) -> None: ... def default_int_arg(n: int = 5) -> None: ... def default_list_arg(l: list = [1, 2, 6, 18]) -> None: ... def default_optional_arg(n: int | None = None) -> None: ... def func_w_anon_args(arg0: int, arg1: int, arg2: int) -> None: ... def func_w_named_pos_args(x: int, y: int, z: int) -> None: ... def generic(*args, **kwargs) -> None: ... @typing.overload def mul(x: int, y: int) -> int: """ Multiply x and y (int) """ @typing.overload def mul(p: float, q: float) -> float: """ Multiply p and q (double) """ def nested_types(arg0: list[Foo] | Foo) -> list[Foo] | Foo: ... def pass_callback(arg0: typing.Callable[[Foo], Foo]) -> Foo: ... def passthrough1(*args, **kwargs): """ passthrough1[T](obj: T) -> T """ @typing.overload def passthrough2() -> None: """ 2. passthrough2[T](obj: T) -> T """ @typing.overload def passthrough3() -> tuple[None, None]: """ 2. passthrough3[T](obj: T) -> tuple[T, None] 3. passthrough3[T1, T2](obj1: T1, obj2: T2) -> tuple[T1, T2] """ def passthrough_backwards(obj: U) -> U: ... def pos_kw_only_mix(i: int, /, j: int, *, k: int) -> tuple: ... def pos_kw_only_variadic_mix(i: int, /, j: int, *args, k: int, **kwargs) -> tuple: ... U: typing.TypeVar # value = ~U issues.pyi000066400000000000000000000021111525537303700365210ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "backslashes_should_be_escaped", "issue_51_catastrophic_regex", "issue_73_utf8_doc_chars", "issue_274_docstring_leading_newline", ] def backslashes_should_be_escaped() -> None: """ \\brief A brief description of this function. A detailed description of this function. Here's some reStructuredText: :math:`x = [x, y, \\theta]^T` """ def issue_274_docstring_leading_newline() -> None: """ This is a docstring """ def issue_51_catastrophic_regex(arg0: int, arg1: int) -> None: """ Use-case: issue_51(os.get_handle_inheritable, os.set_handle_inheritable) """ def issue_73_utf8_doc_chars() -> None: """ Construct a Ramsete unicycle controller. Tuning parameter (b > 0 rad²/m²) for which larger values make convergence more aggressive like a proportional term. Tuning parameter (0 rad⁻¹ < zeta < 1 rad⁻¹) for which larger values provide more damping in response. """ _cleanup: typing.Any # value = methods.pyi000066400000000000000000000003041525537303700366530ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations __all__: list[str] = ["Dummy"] class Dummy: @staticmethod def static_method(arg0: int) -> int: ... def regular_method(self, arg0: int) -> int: ... numpy.pyi000066400000000000000000000012101525537303700363550ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import typing import numpy __all__: list[str] = [ "accept_ndarray_float64", "accept_ndarray_int", "get_ndarray_float64", "get_ndarray_int", "return_dtype", ] def accept_ndarray_float64( arg0: numpy.ndarray[typing.Any, numpy.dtype[numpy.float64]], ) -> None: ... def accept_ndarray_int( arg0: numpy.ndarray[typing.Any, numpy.dtype[numpy.int32]], ) -> None: ... def get_ndarray_float64() -> numpy.ndarray[typing.Any, numpy.dtype[numpy.float64]]: ... def get_ndarray_int() -> numpy.ndarray[typing.Any, numpy.dtype[numpy.int32]]: ... def return_dtype() -> numpy.dtype[typing.Any]: ... properties.pyi000066400000000000000000000045521525537303700374150ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "WithGetterSetterDoc", "WithPropAndGetterSetterDoc", "WithPropDoc", "WithoutDoc", ] class WithoutDoc: """ No user docstring provided """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 def_property: int def_readwrite: int @property def def_property_readonly(self) -> int: ... @property def def_readonly(self) -> int: ... class WithPropDoc: """ User docstring provided only to `def_` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 @property def def_property(self) -> int: """ prop doc token """ @def_property.setter def def_property(self, arg1: int) -> None: ... @property def def_property_readonly(self) -> int: """ prop doc token """ @property def def_readonly(self) -> int: """ prop doc token """ @property def def_readwrite(self) -> int: """ prop doc token """ @def_readwrite.setter def def_readwrite(self, arg0: int) -> None: ... class WithGetterSetterDoc: """ User docstring provided via pybind11::cpp_function(..., doc) to getters/setters, but NOT to `def_*(..., doc)` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 @property def def_property(self) -> int: """ getter doc token """ @def_property.setter def def_property(self, arg1: int) -> None: """ setter doc token """ @property def def_property_readonly(self) -> int: """ getter doc token """ class WithPropAndGetterSetterDoc: """ User docstring provided via pybind11::cpp_function(..., doc) to getters/setters and to `def_*(, doc)` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 @property def def_property(self) -> int: """ prop doc token """ @def_property.setter def def_property(self, arg1: int) -> None: ... @property def def_property_readonly(self) -> int: """ prop doc token """ stl.pyi000066400000000000000000000011061525537303700360130ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import typing import pybind11_stubgen.typing_ext __all__: list[str] = [ "std_array", "std_map", "std_optional", "std_variant", "std_vector", ] def std_array( arg0: typing.Annotated[list[int], pybind11_stubgen.typing_ext.FixedSize(3)], ) -> typing.Annotated[list[int], pybind11_stubgen.typing_ext.FixedSize(3)]: ... def std_map() -> dict[int, complex]: ... def std_optional(arg0: int | None) -> None: ... def std_variant(arg0: int | float | tuple[int, int]) -> None: ... def std_vector() -> list[tuple[int, float]]: ... stl_bind.pyi000066400000000000000000000075701525537303700370220ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "MapStringComplex", "VectorPairStringDouble", "get_complex_map", "get_vector_of_pairs", ] class VectorPairStringDouble: __hash__: typing.ClassVar[None] = None def __bool__(self) -> bool: """ Check whether the list is nonempty """ def __contains__(self, x: tuple[str, float]) -> bool: """ Return true the container contains ``x`` """ @typing.overload def __delitem__(self, arg0: int) -> None: """ Delete the list elements at index ``i`` """ @typing.overload def __delitem__(self, arg0: slice) -> None: """ Delete list elements using a slice object """ def __eq__(self, arg0: VectorPairStringDouble) -> bool: ... @typing.overload def __getitem__(self, s: slice) -> VectorPairStringDouble: """ Retrieve list elements using a slice object """ @typing.overload def __getitem__(self, arg0: int) -> tuple[str, float]: ... @typing.overload def __init__(self) -> None: ... @typing.overload def __init__(self, arg0: VectorPairStringDouble) -> None: """ Copy constructor """ @typing.overload def __init__(self, arg0: typing.Iterable) -> None: ... def __iter__(self) -> typing.Iterator[tuple[str, float]]: ... def __len__(self) -> int: ... def __ne__(self, arg0: VectorPairStringDouble) -> bool: ... @typing.overload def __setitem__(self, arg0: int, arg1: tuple[str, float]) -> None: ... @typing.overload def __setitem__(self, arg0: slice, arg1: VectorPairStringDouble) -> None: """ Assign list elements using a slice object """ def append(self, x: tuple[str, float]) -> None: """ Add an item to the end of the list """ def clear(self) -> None: """ Clear the contents """ def count(self, x: tuple[str, float]) -> int: """ Return the number of times ``x`` appears in the list """ @typing.overload def extend(self, L: VectorPairStringDouble) -> None: """ Extend the list by appending all the items in the given list """ @typing.overload def extend(self, L: typing.Iterable) -> None: """ Extend the list by appending all the items in the given list """ def insert(self, i: int, x: tuple[str, float]) -> None: """ Insert an item at a given position. """ @typing.overload def pop(self) -> tuple[str, float]: """ Remove and return the last item """ @typing.overload def pop(self, i: int) -> tuple[str, float]: """ Remove and return the item at index ``i`` """ def remove(self, x: tuple[str, float]) -> None: """ Remove the first item from the list whose value is x. It is an error if there is no such item. """ class MapStringComplex: def __bool__(self) -> bool: """ Check whether the map is nonempty """ @typing.overload def __contains__(self, arg0: str) -> bool: ... @typing.overload def __contains__(self, arg0: typing.Any) -> bool: ... def __delitem__(self, arg0: str) -> None: ... def __getitem__(self, arg0: str) -> complex: ... def __init__(self) -> None: ... def __iter__(self) -> typing.Iterator[str]: ... def __len__(self) -> int: ... def __repr__(self) -> str: """ Return the canonical string representation of this map. """ def __setitem__(self, arg0: str, arg1: complex) -> None: ... def items(self) -> typing.ItemsView: ... def keys(self) -> typing.KeysView: ... def values(self) -> typing.ValuesView: ... def get_complex_map() -> MapStringComplex: ... def get_vector_of_pairs() -> VectorPairStringDouble: ... typing.pyi000066400000000000000000000004221525537303700365230ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import typing import typing_extensions __all__: list[str] = ["get_buffer", "get_sequence"] def get_buffer(arg0: typing_extensions.Buffer) -> typing_extensions.Buffer: ... def get_sequence(arg0: typing.Sequence) -> typing.Sequence: ... values.pyi000066400000000000000000000014521525537303700365140ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import datetime import numpy from numpy import random __all__: list[str] = [ "Dummy", "Foo", "add_day", "foolist", "foovar", "list_with_none", "none", "random", "t_10ms", "t_20ns", "t_30s", ] class Dummy: linalg = numpy.linalg class Foo: pass def add_day(arg0: datetime.datetime) -> datetime.datetime: ... foolist: list # value = [, ] foovar: Foo # value = list_with_none: list = [None, 2, {}] none = None t_10ms: datetime.timedelta # value = datetime.timedelta(microseconds=10000) t_20ns: datetime.timedelta # value = datetime.timedelta(0) t_30s: datetime.timedelta # value = datetime.timedelta(seconds=30) core.pyi000066400000000000000000000007451525537303700342150ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-use-type-var/demofrom __future__ import annotations from demo._bindings import ( aliases, classes, eigen, enum, flawed_bindings, functions, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) __all__: list[str] = [ "aliases", "classes", "eigen", "enum", "flawed_bindings", "functions", "issues", "methods", "numpy", "properties", "stl", "stl_bind", "typing", "values", ] pure_python/000077500000000000000000000000001525537303700351105ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-use-type-var/demo__init__.pyi000066400000000000000000000003611525537303700373720ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-use-type-var/demo/pure_pythonfrom __future__ import annotations from . import classes, functions, functions_3_8_plus, functions_3_9_plus, values __all__: list[str] = [ "classes", "functions", "functions_3_8_plus", "functions_3_9_plus", "values", ] classes.pyi000066400000000000000000000003071525537303700372700ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-use-type-var/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["A", "B", "C", "X"] class A: """ A """ class B(A): """ B """ class C(B): """ C """ class X: pass functions.pyi000066400000000000000000000015561525537303700376520ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-use-type-var/demo/pure_pythonfrom __future__ import annotations import sys as sys import typing as typing from demo.pure_python.functions_3_8_plus import args_mix from demo.pure_python.functions_3_9_plus import generic_alias_annotation __all__: list[str] = [ "accept_frozenset", "args_mix", "builtin_function_as_default_arg", "function_as_default_arg", "generic_alias_annotation", "lambda_as_default_arg", "search", "static_method_as_default_arg", "sys", "typing", ] class _Dummy: @staticmethod def foo(): ... def accept_frozenset(arg: frozenset[int | float]) -> int | None: ... def builtin_function_as_default_arg(func: type(len) = len): ... def function_as_default_arg(func: type(search) = search): ... def lambda_as_default_arg(callback=...): ... def search(a: int, b: list[int]) -> int: ... def static_method_as_default_arg(callback=_Dummy.foo): ... functions_3_8_plus.pyi000066400000000000000000000007761525537303700413710ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-use-type-var/demo/pure_pythonfrom __future__ import annotations import typing as typing __all__: list[str] = [ "Expression", "Token", "args_mix", "nested_current_module_annotations", "typing", ] class Token: pass class Expression: pass def args_mix( a: int, b: float = 0.5, c: str = "", *args: int, x: int = 1, y=int, **kwargs: dict[int, str], ): ... def nested_current_module_annotations( tokens: list[Token], expr: Expression | None = None ) -> dict[str, Expression]: ... functions_3_9_plus.pyi000066400000000000000000000002601525537303700413560ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-use-type-var/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["generic_alias_annotation"] def generic_alias_annotation(a: list[tuple[int]], b: dict[int, str]) -> list[float]: ... values.pyi000066400000000000000000000001741525537303700371340ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-use-type-var/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["callables_dict"] callables_dict: dict = {"len": len, "int": int} numpy-array-wrap-with-annotated/000077500000000000000000000000001525537303700331445ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13demo/000077500000000000000000000000001525537303700340705ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-wrap-with-annotated__init__.pyi000066400000000000000000000012021525537303700363450ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-wrap-with-annotated/demofrom __future__ import annotations from demo._bindings import ( aliases, classes, eigen, enum, flawed_bindings, functions, hidden_builtins, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) from . import _bindings, core, pure_python __all__: list[str] = [ "aliases", "classes", "core", "eigen", "enum", "flawed_bindings", "functions", "hidden_builtins", "issues", "methods", "numpy", "properties", "pure_python", "stl", "stl_bind", "typing", "values", "version", ] version: str = "0.0.0" _bindings/000077500000000000000000000000001525537303700360245ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-wrap-with-annotated/demo__init__.pyi000066400000000000000000000010041525537303700403010ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations from . import ( aliases, classes, eigen, enum, flawed_bindings, functions, hidden_builtins, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) __all__: list[str] = [ "aliases", "classes", "eigen", "enum", "flawed_bindings", "functions", "hidden_builtins", "issues", "methods", "numpy", "properties", "stl", "stl_bind", "typing", "values", ] aliases/000077500000000000000000000000001525537303700374455ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindings__init__.pyi000066400000000000000000000020761525537303700417340ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import typing import demo._bindings.enum import numpy from demo._bindings.aliases.foreign_method_arg import Bar2 as foreign_type_alias from demo._bindings.aliases.foreign_return import get_foo as foreign_class_alias from numpy import random from . import ( foreign_arg, foreign_attr, foreign_class_member, foreign_method_arg, foreign_method_return, foreign_return, missing_self_arg, ) __all__: list[str] = [ "Color", "Dummy", "foreign_arg", "foreign_attr", "foreign_class_alias", "foreign_class_member", "foreign_enum_default", "foreign_method_arg", "foreign_method_return", "foreign_return", "foreign_type_alias", "func", "local_func_alias", "local_type_alias", "missing_self_arg", "random", ] class Dummy: linalg = numpy.linalg class Color: pass def foreign_enum_default( color: typing.Any = demo._bindings.enum.ConsoleForegroundColor.Blue, ) -> None: ... def func(arg0: int) -> int: ... local_type_alias = Color local_func_alias = func foreign_arg.pyi000066400000000000000000000002371525537303700424540ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["set_foo"] def set_foo(arg0: demo._bindings.classes.Foo) -> int: ... foreign_attr.pyi000066400000000000000000000002631525537303700426540ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["value"] value: demo._bindings.classes.Foo # value = foreign_class_member.pyi000066400000000000000000000003571525537303700443420ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import typing import demo._bindings.classes __all__: list[str] = ["Bar1"] class Bar1: foo: typing.ClassVar[ demo._bindings.classes.Foo ] # value = foreign_method_arg.pyi000066400000000000000000000002621525537303700440120ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar2"] class Bar2: def set_foo(self, arg0: demo._bindings.classes.Foo) -> int: ... foreign_method_return.pyi000066400000000000000000000002651525537303700445630ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar3"] class Bar3: @staticmethod def get_foo() -> demo._bindings.classes.Foo: ... foreign_return.pyi000066400000000000000000000002261525537303700432200ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["get_foo"] def get_foo() -> demo._bindings.classes.Foo: ... missing_self_arg.pyi000066400000000000000000000002541525537303700435040ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar4"] class Bar4: def set_foo(self: demo._bindings.classes.Foo) -> int: ... classes.pyi000066400000000000000000000036571525537303700402170ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "CppException", "Derived", "Foo", "MyBase", "Outer", "ParIter", "ParIterBase", "ParticleContainer", ] class Outer: class Inner: class NestedEnum: """ Members: ONE TWO """ ONE: typing.ClassVar[Outer.Inner.NestedEnum] # value = TWO: typing.ClassVar[Outer.Inner.NestedEnum] # value = __members__: typing.ClassVar[ dict[str, Outer.Inner.NestedEnum] ] # value = {'ONE': , 'TWO': } def __eq__(self, other: typing.Any) -> bool: ... def __getstate__(self) -> int: ... def __hash__(self) -> int: ... def __index__(self) -> int: ... def __init__(self, value: int) -> None: ... def __int__(self) -> int: ... def __ne__(self, other: typing.Any) -> bool: ... def __repr__(self) -> str: ... def __setstate__(self, state: int) -> None: ... def __str__(self) -> str: ... @property def name(self) -> str: ... @property def value(self) -> int: ... value: Outer.Inner.NestedEnum inner: Outer.Inner class MyBase: class Inner: pass name: str class Derived(MyBase): count: int class Foo: class FooChild: def __init__(self) -> None: ... def g(self) -> None: ... def __init__(self) -> None: ... def f(self) -> None: ... class ParIterBase: level: int class ParIter(ParIterBase): def __init__(self, particle_container: ParticleContainer, level: int) -> None: ... class ParticleContainer: name: str Iterator = ParIter def process(self, arg0: ParIter) -> None: ... class CppException(Exception): pass eigen.pyi000066400000000000000000000060031525537303700376350ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing import numpy import scipy.sparse import pybind11_stubgen.typing_ext __all__: list[str] = [ "accept_matrix_int", "accept_vector_float64", "dense_matrix_c", "dense_matrix_r", "fixed_mutator_a", "fixed_mutator_c", "fixed_mutator_r", "four_col_matrix_r", "four_row_matrix_r", "get_matrix_int", "get_vector_float64", "sparse_matrix_c", "sparse_matrix_r", ] def accept_matrix_int( arg0: typing.Annotated[ numpy.ndarray, numpy.int32, pybind11_stubgen.typing_ext.FixedSize(3, 3) ], ) -> None: ... def accept_vector_float64( arg0: typing.Annotated[ numpy.ndarray, numpy.float64, pybind11_stubgen.typing_ext.FixedSize(3, 1) ], ) -> None: ... def dense_matrix_c( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", "n") ], ) -> typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", "n") ]: ... def dense_matrix_r( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", "n") ], ) -> typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", "n") ]: ... def fixed_mutator_a( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.FixedSize(5, 6), numpy.ndarray.flags.writeable, ], ) -> None: ... def fixed_mutator_c( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.FixedSize(5, 6), numpy.ndarray.flags.writeable, numpy.ndarray.flags.f_contiguous, ], ) -> None: ... def fixed_mutator_r( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.FixedSize(5, 6), numpy.ndarray.flags.writeable, numpy.ndarray.flags.c_contiguous, ], ) -> None: ... def four_col_matrix_r( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", 4) ], ) -> typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", 4) ]: ... def four_row_matrix_r( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize(4, "n") ], ) -> typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize(4, "n") ]: ... def get_matrix_int() -> typing.Annotated[ numpy.ndarray, numpy.int32, pybind11_stubgen.typing_ext.FixedSize(3, 3) ]: ... def get_vector_float64() -> typing.Annotated[ numpy.ndarray, numpy.float64, pybind11_stubgen.typing_ext.FixedSize(3, 1) ]: ... def sparse_matrix_c( arg0: typing.Annotated[scipy.sparse.csc_matrix, numpy.float32], ) -> typing.Annotated[scipy.sparse.csc_matrix, numpy.float32]: ... def sparse_matrix_r( arg0: typing.Annotated[scipy.sparse.csr_matrix, numpy.float32], ) -> typing.Annotated[scipy.sparse.csr_matrix, numpy.float32]: ... enum.pyi000066400000000000000000000042501525537303700375140ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "Blue", "ConsoleForegroundColor", "Green", "Magenta", "None_", "Yellow", "accept_defaulted_enum", ] class ConsoleForegroundColor: """ Members: Green Yellow Blue Magenta None_ """ Blue: typing.ClassVar[ ConsoleForegroundColor ] # value = Green: typing.ClassVar[ ConsoleForegroundColor ] # value = Magenta: typing.ClassVar[ ConsoleForegroundColor ] # value = None_: typing.ClassVar[ ConsoleForegroundColor ] # value = Yellow: typing.ClassVar[ ConsoleForegroundColor ] # value = __members__: typing.ClassVar[ dict[str, ConsoleForegroundColor] ] # value = {'Green': , 'Yellow': , 'Blue': , 'Magenta': , 'None_': } def __eq__(self, other: typing.Any) -> bool: ... def __getstate__(self) -> int: ... def __hash__(self) -> int: ... def __index__(self) -> int: ... def __init__(self, value: int) -> None: ... def __int__(self) -> int: ... def __ne__(self, other: typing.Any) -> bool: ... def __repr__(self) -> str: ... def __setstate__(self, state: int) -> None: ... def __str__(self) -> str: ... @property def name(self) -> str: ... @property def value(self) -> int: ... def accept_defaulted_enum( color: ConsoleForegroundColor = ConsoleForegroundColor.None_, ) -> None: ... Blue: ConsoleForegroundColor # value = Green: ConsoleForegroundColor # value = Magenta: ConsoleForegroundColor # value = None_: ConsoleForegroundColor # value = Yellow: ConsoleForegroundColor # value = flawed_bindings.pyi000066400000000000000000000010521525537303700416640ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations __all__: list[str] = [ "Enum", "Unbound", "accept_unbound_enum", "accept_unbound_enum_defaulted", "accept_unbound_type", "accept_unbound_type_defaulted", "get_unbound_type", ] class Unbound: pass class Enum: pass def accept_unbound_enum(arg0: ...) -> int: ... def accept_unbound_enum_defaulted(x: Enum = ...) -> int: ... def accept_unbound_type(arg0: tuple[..., int]) -> int: ... def accept_unbound_type_defaulted(x: Unbound = ...) -> int: ... def get_unbound_type() -> ...: ... functions.pyi000066400000000000000000000045121525537303700405610ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "Foo", "U", "accept_annotated_callable", "accept_callable", "accept_frozenset", "accept_py_handle", "accept_py_object", "accept_set", "add", "default_custom_arg", "default_int_arg", "default_list_arg", "default_optional_arg", "func_w_anon_args", "func_w_named_pos_args", "generic", "mul", "nested_types", "pass_callback", "passthrough1", "passthrough2", "passthrough3", "passthrough_backwards", "pos_kw_only_mix", "pos_kw_only_variadic_mix", ] class Foo: def __init__(self, arg0: int) -> None: ... def accept_annotated_callable(arg0: typing.Callable[[int, int], int]) -> typing.Any: ... def accept_callable(arg0: typing.Callable) -> typing.Any: ... def accept_frozenset(arg0: frozenset) -> None: ... def accept_py_handle(arg0: typing.Any) -> str: ... def accept_py_object(arg0: typing.Any) -> str: ... def accept_set(arg0: set) -> None: ... def add(arg0: int, arg1: int) -> int: ... def default_custom_arg(foo: Foo = Foo(5)) -> None: ... def default_int_arg(n: int = 5) -> None: ... def default_list_arg(l: list = [1, 2, 6, 18]) -> None: ... def default_optional_arg(n: int | None = None) -> None: ... def func_w_anon_args(arg0: int, arg1: int, arg2: int) -> None: ... def func_w_named_pos_args(x: int, y: int, z: int) -> None: ... def generic(*args, **kwargs) -> None: ... @typing.overload def mul(x: int, y: int) -> int: """ Multiply x and y (int) """ @typing.overload def mul(p: float, q: float) -> float: """ Multiply p and q (double) """ def nested_types(arg0: list[Foo] | Foo) -> list[Foo] | Foo: ... def pass_callback(arg0: typing.Callable[[Foo], Foo]) -> Foo: ... def passthrough1(*args, **kwargs): """ passthrough1[T](obj: T) -> T """ @typing.overload def passthrough2() -> None: """ 2. passthrough2[T](obj: T) -> T """ @typing.overload def passthrough3() -> tuple[None, None]: """ 2. passthrough3[T](obj: T) -> tuple[T, None] 3. passthrough3[T1, T2](obj1: T1, obj2: T2) -> tuple[T1, T2] """ def passthrough_backwards(obj: U) -> U: ... def pos_kw_only_mix(i: int, /, j: int, *, k: int) -> tuple: ... def pos_kw_only_variadic_mix(i: int, /, j: int, *args, k: int, **kwargs) -> tuple: ... U: typing.TypeVar # value = ~U hidden_builtins.pyi000066400000000000000000000002571525537303700417170ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import types __all__: list[str] = ["mapping_proxy", "none"] mapping_proxy: types.MappingProxyType # value = mappingproxy({}) none = None issues.pyi000066400000000000000000000021111525537303700400550ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "backslashes_should_be_escaped", "issue_51_catastrophic_regex", "issue_73_utf8_doc_chars", "issue_274_docstring_leading_newline", ] def backslashes_should_be_escaped() -> None: """ \\brief A brief description of this function. A detailed description of this function. Here's some reStructuredText: :math:`x = [x, y, \\theta]^T` """ def issue_274_docstring_leading_newline() -> None: """ This is a docstring """ def issue_51_catastrophic_regex(arg0: int, arg1: int) -> None: """ Use-case: issue_51(os.get_handle_inheritable, os.set_handle_inheritable) """ def issue_73_utf8_doc_chars() -> None: """ Construct a Ramsete unicycle controller. Tuning parameter (b > 0 rad²/m²) for which larger values make convergence more aggressive like a proportional term. Tuning parameter (0 rad⁻¹ < zeta < 1 rad⁻¹) for which larger values provide more damping in response. """ _cleanup: typing.Any # value = methods.pyi000066400000000000000000000003041525537303700402070ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations __all__: list[str] = ["Dummy"] class Dummy: @staticmethod def static_method(arg0: int) -> int: ... def regular_method(self, arg0: int) -> int: ... numpy.pyi000066400000000000000000000011451525537303700377200ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing import numpy __all__: list[str] = [ "accept_ndarray_float64", "accept_ndarray_int", "get_ndarray_float64", "get_ndarray_int", "return_dtype", ] def accept_ndarray_float64( arg0: typing.Annotated[numpy.ndarray, numpy.float64], ) -> None: ... def accept_ndarray_int(arg0: typing.Annotated[numpy.ndarray, numpy.int32]) -> None: ... def get_ndarray_float64() -> typing.Annotated[numpy.ndarray, numpy.float64]: ... def get_ndarray_int() -> typing.Annotated[numpy.ndarray, numpy.int32]: ... def return_dtype() -> numpy.dtype[typing.Any]: ... properties.pyi000066400000000000000000000045431525537303700407510ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "WithGetterSetterDoc", "WithPropAndGetterSetterDoc", "WithPropDoc", "WithoutDoc", ] class WithoutDoc: """ No user docstring provided """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 def_property: int def_readwrite: int @property def def_property_readonly(self) -> int: ... @property def def_readonly(self) -> int: ... class WithPropDoc: """ User docstring provided only to `def_` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 @property def def_property(self) -> int: """ prop doc token """ @def_property.setter def def_property(self, arg1: int) -> None: ... @property def def_property_readonly(self) -> int: """ prop doc token """ @property def def_readonly(self) -> int: """ prop doc token """ @property def def_readwrite(self) -> int: """ prop doc token """ @def_readwrite.setter def def_readwrite(self, arg0: int) -> None: ... class WithGetterSetterDoc: """ User docstring provided via pybind11::cpp_function(..., doc) to getters/setters, but NOT to `def_*(..., doc)` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 @property def def_property(self) -> int: """ getter doc token """ @def_property.setter def def_property(self, arg1: int) -> None: """ setter doc token """ @property def def_property_readonly(self) -> int: """ getter doc token """ class WithPropAndGetterSetterDoc: """ User docstring provided via pybind11::cpp_function(..., doc) to getters/setters and to `def_*(, doc)` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 @property def def_property(self) -> int: """ prop doc token """ @def_property.setter def def_property(self, arg1: int) -> None: ... @property def def_property_readonly(self) -> int: """ prop doc token """ stl.pyi000066400000000000000000000011061525537303700373470ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing import pybind11_stubgen.typing_ext __all__: list[str] = [ "std_array", "std_map", "std_optional", "std_variant", "std_vector", ] def std_array( arg0: typing.Annotated[list[int], pybind11_stubgen.typing_ext.FixedSize(3)], ) -> typing.Annotated[list[int], pybind11_stubgen.typing_ext.FixedSize(3)]: ... def std_map() -> dict[int, complex]: ... def std_optional(arg0: int | None) -> None: ... def std_variant(arg0: int | float | tuple[int, int]) -> None: ... def std_vector() -> list[tuple[int, float]]: ... stl_bind.pyi000066400000000000000000000075471525537303700403620ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "MapStringComplex", "VectorPairStringDouble", "get_complex_map", "get_vector_of_pairs", ] class VectorPairStringDouble: __hash__: typing.ClassVar[None] = None def __bool__(self) -> bool: """ Check whether the list is nonempty """ def __contains__(self, x: tuple[str, float]) -> bool: """ Return true the container contains ``x`` """ @typing.overload def __delitem__(self, arg0: int) -> None: """ Delete the list elements at index ``i`` """ @typing.overload def __delitem__(self, arg0: slice) -> None: """ Delete list elements using a slice object """ def __eq__(self, arg0: VectorPairStringDouble) -> bool: ... @typing.overload def __getitem__(self, s: slice) -> VectorPairStringDouble: """ Retrieve list elements using a slice object """ @typing.overload def __getitem__(self, arg0: int) -> tuple[str, float]: ... @typing.overload def __init__(self) -> None: ... @typing.overload def __init__(self, arg0: VectorPairStringDouble) -> None: """ Copy constructor """ @typing.overload def __init__(self, arg0: typing.Iterable) -> None: ... def __iter__(self) -> typing.Iterator[tuple[str, float]]: ... def __len__(self) -> int: ... def __ne__(self, arg0: VectorPairStringDouble) -> bool: ... @typing.overload def __setitem__(self, arg0: int, arg1: tuple[str, float]) -> None: ... @typing.overload def __setitem__(self, arg0: slice, arg1: VectorPairStringDouble) -> None: """ Assign list elements using a slice object """ def append(self, x: tuple[str, float]) -> None: """ Add an item to the end of the list """ def clear(self) -> None: """ Clear the contents """ def count(self, x: tuple[str, float]) -> int: """ Return the number of times ``x`` appears in the list """ @typing.overload def extend(self, L: VectorPairStringDouble) -> None: """ Extend the list by appending all the items in the given list """ @typing.overload def extend(self, L: typing.Iterable) -> None: """ Extend the list by appending all the items in the given list """ def insert(self, i: int, x: tuple[str, float]) -> None: """ Insert an item at a given position. """ @typing.overload def pop(self) -> tuple[str, float]: """ Remove and return the last item """ @typing.overload def pop(self, i: int) -> tuple[str, float]: """ Remove and return the item at index ``i`` """ def remove(self, x: tuple[str, float]) -> None: """ Remove the first item from the list whose value is x. It is an error if there is no such item. """ class MapStringComplex: def __bool__(self) -> bool: """ Check whether the map is nonempty """ @typing.overload def __contains__(self, arg0: str) -> bool: ... @typing.overload def __contains__(self, arg0: typing.Any) -> bool: ... def __delitem__(self, arg0: str) -> None: ... def __getitem__(self, arg0: str) -> complex: ... def __init__(self) -> None: ... def __iter__(self) -> typing.Iterator[str]: ... def __len__(self) -> int: ... def __repr__(self) -> str: """ Return the canonical string representation of this map. """ def __setitem__(self, arg0: str, arg1: complex) -> None: ... def items(self) -> typing.ItemsView: ... def keys(self) -> typing.KeysView: ... def values(self) -> typing.ValuesView: ... def get_complex_map() -> MapStringComplex: ... def get_vector_of_pairs() -> VectorPairStringDouble: ... typing.pyi000066400000000000000000000004221525537303700400570ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing import typing_extensions __all__: list[str] = ["get_buffer", "get_sequence"] def get_buffer(arg0: typing_extensions.Buffer) -> typing_extensions.Buffer: ... def get_sequence(arg0: typing.Sequence) -> typing.Sequence: ... values.pyi000066400000000000000000000014521525537303700400500ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import datetime import numpy from numpy import random __all__: list[str] = [ "Dummy", "Foo", "add_day", "foolist", "foovar", "list_with_none", "none", "random", "t_10ms", "t_20ns", "t_30s", ] class Dummy: linalg = numpy.linalg class Foo: pass def add_day(arg0: datetime.datetime) -> datetime.datetime: ... foolist: list # value = [, ] foovar: Foo # value = list_with_none: list = [None, 2, {}] none = None t_10ms: datetime.timedelta # value = datetime.timedelta(microseconds=10000) t_20ns: datetime.timedelta # value = datetime.timedelta(0) t_30s: datetime.timedelta # value = datetime.timedelta(seconds=30) core.pyi000066400000000000000000000010211525537303700355350ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-wrap-with-annotated/demofrom __future__ import annotations from demo._bindings import ( aliases, classes, eigen, enum, flawed_bindings, functions, hidden_builtins, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) __all__: list[str] = [ "aliases", "classes", "eigen", "enum", "flawed_bindings", "functions", "hidden_builtins", "issues", "methods", "numpy", "properties", "stl", "stl_bind", "typing", "values", ] pure_python/000077500000000000000000000000001525537303700364445ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-wrap-with-annotated/demo__init__.pyi000066400000000000000000000003611525537303700407260ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations from . import classes, functions, functions_3_8_plus, functions_3_9_plus, values __all__: list[str] = [ "classes", "functions", "functions_3_8_plus", "functions_3_9_plus", "values", ] classes.pyi000066400000000000000000000003071525537303700406240ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["A", "B", "C", "X"] class A: """ A """ class B(A): """ B """ class C(B): """ C """ class X: pass functions.pyi000066400000000000000000000015561525537303700412060ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations import sys as sys import typing as typing from demo.pure_python.functions_3_8_plus import args_mix from demo.pure_python.functions_3_9_plus import generic_alias_annotation __all__: list[str] = [ "accept_frozenset", "args_mix", "builtin_function_as_default_arg", "function_as_default_arg", "generic_alias_annotation", "lambda_as_default_arg", "search", "static_method_as_default_arg", "sys", "typing", ] class _Dummy: @staticmethod def foo(): ... def accept_frozenset(arg: frozenset[int | float]) -> int | None: ... def builtin_function_as_default_arg(func: type(len) = len): ... def function_as_default_arg(func: type(search) = search): ... def lambda_as_default_arg(callback=...): ... def search(a: int, b: list[int]) -> int: ... def static_method_as_default_arg(callback=_Dummy.foo): ... functions_3_8_plus.pyi000066400000000000000000000007761525537303700427250ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations import typing as typing __all__: list[str] = [ "Expression", "Token", "args_mix", "nested_current_module_annotations", "typing", ] class Token: pass class Expression: pass def args_mix( a: int, b: float = 0.5, c: str = "", *args: int, x: int = 1, y=int, **kwargs: dict[int, str], ): ... def nested_current_module_annotations( tokens: list[Token], expr: Expression | None = None ) -> dict[str, Expression]: ... functions_3_9_plus.pyi000066400000000000000000000002601525537303700427120ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["generic_alias_annotation"] def generic_alias_annotation(a: list[tuple[int]], b: dict[int, str]) -> list[float]: ... values.pyi000066400000000000000000000001741525537303700404700ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["callables_dict"] callables_dict: dict = {"len": len, "int": int} pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.9/000077500000000000000000000000001525537303700247715ustar00rootroot00000000000000numpy-array-wrap-with-annotated/000077500000000000000000000000001525537303700330715ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.9demo/000077500000000000000000000000001525537303700340155ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.9/numpy-array-wrap-with-annotated__init__.pyi000066400000000000000000000011261525537303700362770ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.9/numpy-array-wrap-with-annotated/demofrom __future__ import annotations from demo._bindings import ( aliases, classes, eigen, enum, flawed_bindings, functions, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) from . import _bindings, core, pure_python __all__: list[str] = [ "aliases", "classes", "core", "eigen", "enum", "flawed_bindings", "functions", "issues", "methods", "numpy", "properties", "pure_python", "stl", "stl_bind", "typing", "values", "version", ] version: str = "0.0.0" _bindings/000077500000000000000000000000001525537303700357515ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.9/numpy-array-wrap-with-annotated/demo__init__.pyi000066400000000000000000000007301525537303700402330ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations from . import ( aliases, classes, eigen, enum, flawed_bindings, functions, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) __all__: list[str] = [ "aliases", "classes", "eigen", "enum", "flawed_bindings", "functions", "issues", "methods", "numpy", "properties", "stl", "stl_bind", "typing", "values", ] aliases/000077500000000000000000000000001525537303700373725ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindings__init__.pyi000066400000000000000000000020761525537303700416610ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import typing import demo._bindings.enum import numpy from demo._bindings.aliases.foreign_method_arg import Bar2 as foreign_type_alias from demo._bindings.aliases.foreign_return import get_foo as foreign_class_alias from numpy import random from . import ( foreign_arg, foreign_attr, foreign_class_member, foreign_method_arg, foreign_method_return, foreign_return, missing_self_arg, ) __all__: list[str] = [ "Color", "Dummy", "foreign_arg", "foreign_attr", "foreign_class_alias", "foreign_class_member", "foreign_enum_default", "foreign_method_arg", "foreign_method_return", "foreign_return", "foreign_type_alias", "func", "local_func_alias", "local_type_alias", "missing_self_arg", "random", ] class Dummy: linalg = numpy.linalg class Color: pass def foreign_enum_default( color: typing.Any = demo._bindings.enum.ConsoleForegroundColor.Blue, ) -> None: ... def func(arg0: int) -> int: ... local_type_alias = Color local_func_alias = func foreign_arg.pyi000066400000000000000000000002371525537303700424010ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["set_foo"] def set_foo(arg0: demo._bindings.classes.Foo) -> int: ... foreign_attr.pyi000066400000000000000000000002631525537303700426010ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["value"] value: demo._bindings.classes.Foo # value = foreign_class_member.pyi000066400000000000000000000003571525537303700442670ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import typing import demo._bindings.classes __all__: list[str] = ["Bar1"] class Bar1: foo: typing.ClassVar[ demo._bindings.classes.Foo ] # value = foreign_method_arg.pyi000066400000000000000000000002621525537303700437370ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar2"] class Bar2: def set_foo(self, arg0: demo._bindings.classes.Foo) -> int: ... foreign_method_return.pyi000066400000000000000000000002651525537303700445100ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar3"] class Bar3: @staticmethod def get_foo() -> demo._bindings.classes.Foo: ... foreign_return.pyi000066400000000000000000000002261525537303700431450ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["get_foo"] def get_foo() -> demo._bindings.classes.Foo: ... missing_self_arg.pyi000066400000000000000000000002541525537303700434310ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar4"] class Bar4: def set_foo(self: demo._bindings.classes.Foo) -> int: ... classes.pyi000066400000000000000000000036571525537303700401440ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "CppException", "Derived", "Foo", "MyBase", "Outer", "ParIter", "ParIterBase", "ParticleContainer", ] class Outer: class Inner: class NestedEnum: """ Members: ONE TWO """ ONE: typing.ClassVar[Outer.Inner.NestedEnum] # value = TWO: typing.ClassVar[Outer.Inner.NestedEnum] # value = __members__: typing.ClassVar[ dict[str, Outer.Inner.NestedEnum] ] # value = {'ONE': , 'TWO': } def __eq__(self, other: typing.Any) -> bool: ... def __getstate__(self) -> int: ... def __hash__(self) -> int: ... def __index__(self) -> int: ... def __init__(self, value: int) -> None: ... def __int__(self) -> int: ... def __ne__(self, other: typing.Any) -> bool: ... def __repr__(self) -> str: ... def __setstate__(self, state: int) -> None: ... def __str__(self) -> str: ... @property def name(self) -> str: ... @property def value(self) -> int: ... value: Outer.Inner.NestedEnum inner: Outer.Inner class MyBase: class Inner: pass name: str class Derived(MyBase): count: int class Foo: class FooChild: def __init__(self) -> None: ... def g(self) -> None: ... def __init__(self) -> None: ... def f(self) -> None: ... class ParIterBase: level: int class ParIter(ParIterBase): def __init__(self, particle_container: ParticleContainer, level: int) -> None: ... class ParticleContainer: name: str Iterator = ParIter def process(self, arg0: ParIter) -> None: ... class CppException(Exception): pass eigen.pyi000066400000000000000000000060031525537303700375620ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing import numpy import scipy.sparse import pybind11_stubgen.typing_ext __all__: list[str] = [ "accept_matrix_int", "accept_vector_float64", "dense_matrix_c", "dense_matrix_r", "fixed_mutator_a", "fixed_mutator_c", "fixed_mutator_r", "four_col_matrix_r", "four_row_matrix_r", "get_matrix_int", "get_vector_float64", "sparse_matrix_c", "sparse_matrix_r", ] def accept_matrix_int( arg0: typing.Annotated[ numpy.ndarray, numpy.int32, pybind11_stubgen.typing_ext.FixedSize(3, 3) ], ) -> None: ... def accept_vector_float64( arg0: typing.Annotated[ numpy.ndarray, numpy.float64, pybind11_stubgen.typing_ext.FixedSize(3, 1) ], ) -> None: ... def dense_matrix_c( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", "n") ], ) -> typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", "n") ]: ... def dense_matrix_r( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", "n") ], ) -> typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", "n") ]: ... def fixed_mutator_a( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.FixedSize(5, 6), numpy.ndarray.flags.writeable, ], ) -> None: ... def fixed_mutator_c( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.FixedSize(5, 6), numpy.ndarray.flags.writeable, numpy.ndarray.flags.f_contiguous, ], ) -> None: ... def fixed_mutator_r( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.FixedSize(5, 6), numpy.ndarray.flags.writeable, numpy.ndarray.flags.c_contiguous, ], ) -> None: ... def four_col_matrix_r( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", 4) ], ) -> typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", 4) ]: ... def four_row_matrix_r( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize(4, "n") ], ) -> typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize(4, "n") ]: ... def get_matrix_int() -> typing.Annotated[ numpy.ndarray, numpy.int32, pybind11_stubgen.typing_ext.FixedSize(3, 3) ]: ... def get_vector_float64() -> typing.Annotated[ numpy.ndarray, numpy.float64, pybind11_stubgen.typing_ext.FixedSize(3, 1) ]: ... def sparse_matrix_c( arg0: typing.Annotated[scipy.sparse.csc_matrix, numpy.float32], ) -> typing.Annotated[scipy.sparse.csc_matrix, numpy.float32]: ... def sparse_matrix_r( arg0: typing.Annotated[scipy.sparse.csr_matrix, numpy.float32], ) -> typing.Annotated[scipy.sparse.csr_matrix, numpy.float32]: ... enum.pyi000066400000000000000000000042501525537303700374410ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "Blue", "ConsoleForegroundColor", "Green", "Magenta", "None_", "Yellow", "accept_defaulted_enum", ] class ConsoleForegroundColor: """ Members: Green Yellow Blue Magenta None_ """ Blue: typing.ClassVar[ ConsoleForegroundColor ] # value = Green: typing.ClassVar[ ConsoleForegroundColor ] # value = Magenta: typing.ClassVar[ ConsoleForegroundColor ] # value = None_: typing.ClassVar[ ConsoleForegroundColor ] # value = Yellow: typing.ClassVar[ ConsoleForegroundColor ] # value = __members__: typing.ClassVar[ dict[str, ConsoleForegroundColor] ] # value = {'Green': , 'Yellow': , 'Blue': , 'Magenta': , 'None_': } def __eq__(self, other: typing.Any) -> bool: ... def __getstate__(self) -> int: ... def __hash__(self) -> int: ... def __index__(self) -> int: ... def __init__(self, value: int) -> None: ... def __int__(self) -> int: ... def __ne__(self, other: typing.Any) -> bool: ... def __repr__(self) -> str: ... def __setstate__(self, state: int) -> None: ... def __str__(self) -> str: ... @property def name(self) -> str: ... @property def value(self) -> int: ... def accept_defaulted_enum( color: ConsoleForegroundColor = ConsoleForegroundColor.None_, ) -> None: ... Blue: ConsoleForegroundColor # value = Green: ConsoleForegroundColor # value = Magenta: ConsoleForegroundColor # value = None_: ConsoleForegroundColor # value = Yellow: ConsoleForegroundColor # value = flawed_bindings.pyi000066400000000000000000000010521525537303700416110ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations __all__: list[str] = [ "Enum", "Unbound", "accept_unbound_enum", "accept_unbound_enum_defaulted", "accept_unbound_type", "accept_unbound_type_defaulted", "get_unbound_type", ] class Unbound: pass class Enum: pass def accept_unbound_enum(arg0: ...) -> int: ... def accept_unbound_enum_defaulted(x: Enum = ...) -> int: ... def accept_unbound_type(arg0: tuple[..., int]) -> int: ... def accept_unbound_type_defaulted(x: Unbound = ...) -> int: ... def get_unbound_type() -> ...: ... functions.pyi000066400000000000000000000042051525537303700405050ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "Foo", "U", "accept_callable", "accept_py_handle", "accept_py_object", "accept_set", "add", "default_custom_arg", "default_int_arg", "default_list_arg", "default_optional_arg", "func_w_anon_args", "func_w_named_pos_args", "generic", "mul", "nested_types", "pass_callback", "passthrough1", "passthrough2", "passthrough3", "passthrough_backwards", "pos_kw_only_mix", "pos_kw_only_variadic_mix", ] class Foo: def __init__(self, arg0: int) -> None: ... def accept_callable(arg0: typing.Callable) -> typing.Any: ... def accept_py_handle(arg0: typing.Any) -> str: ... def accept_py_object(arg0: typing.Any) -> str: ... def accept_set(arg0: set) -> None: ... def add(arg0: int, arg1: int) -> int: ... def default_custom_arg(foo: Foo = Foo(5)) -> None: ... def default_int_arg(n: int = 5) -> None: ... def default_list_arg(l: list = [1, 2, 6, 18]) -> None: ... def default_optional_arg(n: int | None = None) -> None: ... def func_w_anon_args(arg0: int, arg1: int, arg2: int) -> None: ... def func_w_named_pos_args(x: int, y: int, z: int) -> None: ... def generic(*args, **kwargs) -> None: ... @typing.overload def mul(x: int, y: int) -> int: """ Multiply x and y (int) """ @typing.overload def mul(p: float, q: float) -> float: """ Multiply p and q (double) """ def nested_types(arg0: list[Foo] | Foo) -> list[Foo] | Foo: ... def pass_callback(arg0: typing.Callable[[Foo], Foo]) -> Foo: ... def passthrough1(*args, **kwargs): """ passthrough1[T](obj: T) -> T """ @typing.overload def passthrough2() -> None: """ 2. passthrough2[T](obj: T) -> T """ @typing.overload def passthrough3() -> tuple[None, None]: """ 2. passthrough3[T](obj: T) -> tuple[T, None] 3. passthrough3[T1, T2](obj1: T1, obj2: T2) -> tuple[T1, T2] """ def passthrough_backwards(obj: U) -> U: ... def pos_kw_only_mix(i: int, /, j: int, *, k: int) -> tuple: ... def pos_kw_only_variadic_mix(i: int, /, j: int, *args, k: int, **kwargs) -> tuple: ... U: typing.TypeVar # value = ~U issues.pyi000066400000000000000000000021111525537303700400020ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "backslashes_should_be_escaped", "issue_51_catastrophic_regex", "issue_73_utf8_doc_chars", "issue_274_docstring_leading_newline", ] def backslashes_should_be_escaped() -> None: """ \\brief A brief description of this function. A detailed description of this function. Here's some reStructuredText: :math:`x = [x, y, \\theta]^T` """ def issue_274_docstring_leading_newline() -> None: """ This is a docstring """ def issue_51_catastrophic_regex(arg0: int, arg1: int) -> None: """ Use-case: issue_51(os.get_handle_inheritable, os.set_handle_inheritable) """ def issue_73_utf8_doc_chars() -> None: """ Construct a Ramsete unicycle controller. Tuning parameter (b > 0 rad²/m²) for which larger values make convergence more aggressive like a proportional term. Tuning parameter (0 rad⁻¹ < zeta < 1 rad⁻¹) for which larger values provide more damping in response. """ _cleanup: typing.Any # value = methods.pyi000066400000000000000000000003041525537303700401340ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations __all__: list[str] = ["Dummy"] class Dummy: @staticmethod def static_method(arg0: int) -> int: ... def regular_method(self, arg0: int) -> int: ... numpy.pyi000066400000000000000000000011451525537303700376450ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing import numpy __all__: list[str] = [ "accept_ndarray_float64", "accept_ndarray_int", "get_ndarray_float64", "get_ndarray_int", "return_dtype", ] def accept_ndarray_float64( arg0: typing.Annotated[numpy.ndarray, numpy.float64], ) -> None: ... def accept_ndarray_int(arg0: typing.Annotated[numpy.ndarray, numpy.int32]) -> None: ... def get_ndarray_float64() -> typing.Annotated[numpy.ndarray, numpy.float64]: ... def get_ndarray_int() -> typing.Annotated[numpy.ndarray, numpy.int32]: ... def return_dtype() -> numpy.dtype[typing.Any]: ... properties.pyi000066400000000000000000000045521525537303700406760ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "WithGetterSetterDoc", "WithPropAndGetterSetterDoc", "WithPropDoc", "WithoutDoc", ] class WithoutDoc: """ No user docstring provided """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 def_property: int def_readwrite: int @property def def_property_readonly(self) -> int: ... @property def def_readonly(self) -> int: ... class WithPropDoc: """ User docstring provided only to `def_` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 @property def def_property(self) -> int: """ prop doc token """ @def_property.setter def def_property(self, arg1: int) -> None: ... @property def def_property_readonly(self) -> int: """ prop doc token """ @property def def_readonly(self) -> int: """ prop doc token """ @property def def_readwrite(self) -> int: """ prop doc token """ @def_readwrite.setter def def_readwrite(self, arg0: int) -> None: ... class WithGetterSetterDoc: """ User docstring provided via pybind11::cpp_function(..., doc) to getters/setters, but NOT to `def_*(..., doc)` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 @property def def_property(self) -> int: """ getter doc token """ @def_property.setter def def_property(self, arg1: int) -> None: """ setter doc token """ @property def def_property_readonly(self) -> int: """ getter doc token """ class WithPropAndGetterSetterDoc: """ User docstring provided via pybind11::cpp_function(..., doc) to getters/setters and to `def_*(, doc)` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 @property def def_property(self) -> int: """ prop doc token """ @def_property.setter def def_property(self, arg1: int) -> None: ... @property def def_property_readonly(self) -> int: """ prop doc token """ stl.pyi000066400000000000000000000006511525537303700373000ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "std_array", "std_map", "std_optional", "std_variant", "std_vector", ] def std_array(arg0: list[int[3]]) -> list[int[3]]: ... def std_map() -> dict[int, complex]: ... def std_optional(arg0: int | None) -> None: ... def std_variant(arg0: int | float | tuple[int, int]) -> None: ... def std_vector() -> list[tuple[int, float]]: ... stl_bind.pyi000066400000000000000000000076261525537303700403050ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "MapStringComplex", "VectorPairStringDouble", "get_complex_map", "get_vector_of_pairs", ] class VectorPairStringDouble: __hash__: typing.ClassVar[None] = None def __bool__(self) -> bool: """ Check whether the list is nonempty """ def __contains__(self, x: tuple[str, float]) -> bool: """ Return true the container contains ``x`` """ @typing.overload def __delitem__(self, arg0: int) -> None: """ Delete the list elements at index ``i`` """ @typing.overload def __delitem__(self, arg0: slice) -> None: """ Delete list elements using a slice object """ def __eq__(self, arg0: VectorPairStringDouble) -> bool: ... @typing.overload def __getitem__(self, s: slice) -> VectorPairStringDouble: """ Retrieve list elements using a slice object """ @typing.overload def __getitem__(self, arg0: int) -> tuple[str, float]: ... @typing.overload def __init__(self) -> None: ... @typing.overload def __init__(self, arg0: VectorPairStringDouble) -> None: """ Copy constructor """ @typing.overload def __init__(self, arg0: typing.Iterable) -> None: ... def __iter__(self) -> typing.Iterator: ... def __len__(self) -> int: ... def __ne__(self, arg0: VectorPairStringDouble) -> bool: ... @typing.overload def __setitem__(self, arg0: int, arg1: tuple[str, float]) -> None: ... @typing.overload def __setitem__(self, arg0: slice, arg1: VectorPairStringDouble) -> None: """ Assign list elements using a slice object """ def append(self, x: tuple[str, float]) -> None: """ Add an item to the end of the list """ def clear(self) -> None: """ Clear the contents """ def count(self, x: tuple[str, float]) -> int: """ Return the number of times ``x`` appears in the list """ @typing.overload def extend(self, L: VectorPairStringDouble) -> None: """ Extend the list by appending all the items in the given list """ @typing.overload def extend(self, L: typing.Iterable) -> None: """ Extend the list by appending all the items in the given list """ def insert(self, i: int, x: tuple[str, float]) -> None: """ Insert an item at a given position. """ @typing.overload def pop(self) -> tuple[str, float]: """ Remove and return the last item """ @typing.overload def pop(self, i: int) -> tuple[str, float]: """ Remove and return the item at index ``i`` """ def remove(self, x: tuple[str, float]) -> None: """ Remove the first item from the list whose value is x. It is an error if there is no such item. """ class MapStringComplex: def __bool__(self) -> bool: """ Check whether the map is nonempty """ @typing.overload def __contains__(self, arg0: str) -> bool: ... @typing.overload def __contains__(self, arg0: typing.Any) -> bool: ... def __delitem__(self, arg0: str) -> None: ... def __getitem__(self, arg0: str) -> complex: ... def __init__(self) -> None: ... def __iter__(self) -> typing.Iterator: ... def __len__(self) -> int: ... def __repr__(self) -> str: """ Return the canonical string representation of this map. """ def __setitem__(self, arg0: str, arg1: complex) -> None: ... def items(self) -> typing.ItemsView[MapStringComplex]: ... def keys(self) -> typing.KeysView[MapStringComplex]: ... def values(self) -> typing.ValuesView[MapStringComplex]: ... def get_complex_map() -> MapStringComplex: ... def get_vector_of_pairs() -> VectorPairStringDouble: ... typing.pyi000066400000000000000000000004221525537303700400040ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing import typing_extensions __all__: list[str] = ["get_buffer", "get_sequence"] def get_buffer(arg0: typing_extensions.Buffer) -> typing_extensions.Buffer: ... def get_sequence(arg0: typing.Sequence) -> typing.Sequence: ... values.pyi000066400000000000000000000014521525537303700377750ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import datetime import numpy from numpy import random __all__: list[str] = [ "Dummy", "Foo", "add_day", "foolist", "foovar", "list_with_none", "none", "random", "t_10ms", "t_20ns", "t_30s", ] class Dummy: linalg = numpy.linalg class Foo: pass def add_day(arg0: datetime.datetime) -> datetime.datetime: ... foolist: list # value = [, ] foovar: Foo # value = list_with_none: list = [None, 2, {}] none = None t_10ms: datetime.timedelta # value = datetime.timedelta(microseconds=10000) t_20ns: datetime.timedelta # value = datetime.timedelta(0) t_30s: datetime.timedelta # value = datetime.timedelta(seconds=30) core.pyi000066400000000000000000000007451525537303700354760ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.9/numpy-array-wrap-with-annotated/demofrom __future__ import annotations from demo._bindings import ( aliases, classes, eigen, enum, flawed_bindings, functions, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) __all__: list[str] = [ "aliases", "classes", "eigen", "enum", "flawed_bindings", "functions", "issues", "methods", "numpy", "properties", "stl", "stl_bind", "typing", "values", ] pure_python/000077500000000000000000000000001525537303700363715ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.9/numpy-array-wrap-with-annotated/demo__init__.pyi000066400000000000000000000003611525537303700406530ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations from . import classes, functions, functions_3_8_plus, functions_3_9_plus, values __all__: list[str] = [ "classes", "functions", "functions_3_8_plus", "functions_3_9_plus", "values", ] classes.pyi000066400000000000000000000003071525537303700405510ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["A", "B", "C", "X"] class A: """ A """ class B(A): """ B """ class C(B): """ C """ class X: pass functions.pyi000066400000000000000000000015561525537303700411330ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations import sys as sys import typing as typing from demo.pure_python.functions_3_8_plus import args_mix from demo.pure_python.functions_3_9_plus import generic_alias_annotation __all__: list[str] = [ "accept_frozenset", "args_mix", "builtin_function_as_default_arg", "function_as_default_arg", "generic_alias_annotation", "lambda_as_default_arg", "search", "static_method_as_default_arg", "sys", "typing", ] class _Dummy: @staticmethod def foo(): ... def accept_frozenset(arg: frozenset[int | float]) -> int | None: ... def builtin_function_as_default_arg(func: type(len) = len): ... def function_as_default_arg(func: type(search) = search): ... def lambda_as_default_arg(callback=...): ... def search(a: int, b: list[int]) -> int: ... def static_method_as_default_arg(callback=_Dummy.foo): ... functions_3_8_plus.pyi000066400000000000000000000007761525537303700426520ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations import typing as typing __all__: list[str] = [ "Expression", "Token", "args_mix", "nested_current_module_annotations", "typing", ] class Token: pass class Expression: pass def args_mix( a: int, b: float = 0.5, c: str = "", *args: int, x: int = 1, y=int, **kwargs: dict[int, str], ): ... def nested_current_module_annotations( tokens: list[Token], expr: Expression | None = None ) -> dict[str, Expression]: ... functions_3_9_plus.pyi000066400000000000000000000002601525537303700426370ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["generic_alias_annotation"] def generic_alias_annotation(a: list[tuple[int]], b: dict[int, str]) -> list[float]: ... values.pyi000066400000000000000000000001741525537303700404150ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["callables_dict"] callables_dict: dict = {"len": len, "int": int} pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/000077500000000000000000000000001525537303700247615ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-use-type-var/000077500000000000000000000000001525537303700316045ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-use-type-var/demo/000077500000000000000000000000001525537303700325305ustar00rootroot00000000000000__init__.pyi000066400000000000000000000011261525537303700347330ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-use-type-var/demofrom __future__ import annotations from demo._bindings import ( aliases, classes, eigen, enum, flawed_bindings, functions, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) from . import _bindings, core, pure_python __all__: list[str] = [ "aliases", "classes", "core", "eigen", "enum", "flawed_bindings", "functions", "issues", "methods", "numpy", "properties", "pure_python", "stl", "stl_bind", "typing", "values", "version", ] version: str = "0.0.0" _bindings/000077500000000000000000000000001525537303700344055ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-use-type-var/demo__init__.pyi000066400000000000000000000007301525537303700366670ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations from . import ( aliases, classes, eigen, enum, flawed_bindings, functions, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) __all__: list[str] = [ "aliases", "classes", "eigen", "enum", "flawed_bindings", "functions", "issues", "methods", "numpy", "properties", "stl", "stl_bind", "typing", "values", ] aliases/000077500000000000000000000000001525537303700360265ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-use-type-var/demo/_bindings__init__.pyi000066400000000000000000000021441525537303700403110ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-use-type-var/demo/_bindings/aliasesfrom __future__ import annotations import typing import demo._bindings.enum import numpy from demo._bindings.aliases.foreign_method_arg import Bar2 as foreign_type_alias from demo._bindings.aliases.foreign_return import get_foo as foreign_class_alias from numpy import random from . import ( foreign_arg, foreign_attr, foreign_class_member, foreign_method_arg, foreign_method_return, foreign_return, missing_self_arg, ) __all__: list[str] = [ "Color", "Dummy", "foreign_arg", "foreign_attr", "foreign_class_alias", "foreign_class_member", "foreign_enum_default", "foreign_method_arg", "foreign_method_return", "foreign_return", "foreign_type_alias", "func", "local_func_alias", "local_type_alias", "missing_self_arg", "random", ] class Dummy: linalg = numpy.linalg class Color: pass def foreign_enum_default( color: typing.Any = demo._bindings.enum.ConsoleForegroundColor.Blue, ) -> None: ... def func(arg0: typing.SupportsInt | typing.SupportsIndex) -> int: ... local_type_alias = Color local_func_alias = func foreign_arg.pyi000066400000000000000000000002371525537303700410350ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-use-type-var/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["set_foo"] def set_foo(arg0: demo._bindings.classes.Foo) -> int: ... foreign_attr.pyi000066400000000000000000000002631525537303700412350ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-use-type-var/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["value"] value: demo._bindings.classes.Foo # value = foreign_class_member.pyi000066400000000000000000000003571525537303700427230ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-use-type-var/demo/_bindings/aliasesfrom __future__ import annotations import typing import demo._bindings.classes __all__: list[str] = ["Bar1"] class Bar1: foo: typing.ClassVar[ demo._bindings.classes.Foo ] # value = foreign_method_arg.pyi000066400000000000000000000002621525537303700423730ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-use-type-var/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar2"] class Bar2: def set_foo(self, arg0: demo._bindings.classes.Foo) -> int: ... foreign_method_return.pyi000066400000000000000000000002651525537303700431440ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-use-type-var/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar3"] class Bar3: @staticmethod def get_foo() -> demo._bindings.classes.Foo: ... foreign_return.pyi000066400000000000000000000002261525537303700416010ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-use-type-var/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["get_foo"] def get_foo() -> demo._bindings.classes.Foo: ... missing_self_arg.pyi000066400000000000000000000002541525537303700420650ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-use-type-var/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar4"] class Bar4: def set_foo(self: demo._bindings.classes.Foo) -> int: ... classes.pyi000066400000000000000000000046021525537303700365670ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "CppException", "Derived", "Foo", "MyBase", "Outer", "ParIter", "ParIterBase", "ParticleContainer", ] class Outer: class Inner: class NestedEnum: """ Members: ONE TWO """ ONE: typing.ClassVar[Outer.Inner.NestedEnum] # value = TWO: typing.ClassVar[Outer.Inner.NestedEnum] # value = __members__: typing.ClassVar[ dict[str, Outer.Inner.NestedEnum] ] # value = {'ONE': , 'TWO': } def __eq__(self, other: typing.Any) -> bool: ... def __getstate__(self) -> int: ... def __hash__(self) -> int: ... def __index__(self) -> int: ... def __init__( self, value: typing.SupportsInt | typing.SupportsIndex ) -> None: ... def __int__(self) -> int: ... def __ne__(self, other: typing.Any) -> bool: ... def __repr__(self) -> str: ... def __setstate__( self, state: typing.SupportsInt | typing.SupportsIndex ) -> None: ... def __str__(self) -> str: ... @property def name(self) -> str: ... @property def value(self) -> int: ... value: Outer.Inner.NestedEnum inner: Outer.Inner class MyBase: class Inner: pass name: str class Derived(MyBase): @property def count(self) -> int: ... @count.setter def count(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None: ... class Foo: class FooChild: def __init__(self) -> None: ... def g(self) -> None: ... def __init__(self) -> None: ... def f(self) -> None: ... class ParIterBase: @property def level(self) -> int: ... @level.setter def level(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None: ... class ParIter(ParIterBase): def __init__( self, particle_container: ParticleContainer, level: typing.SupportsInt | typing.SupportsIndex, ) -> None: ... class ParticleContainer: name: str Iterator = ParIter def process(self, arg0: ParIter) -> None: ... class CppException(Exception): pass eigen.pyi000066400000000000000000000043201525537303700362160ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import typing import numpy import numpy.typing import scipy.sparse __all__: list[str] = [ "accept_matrix_int", "accept_vector_float64", "dense_matrix_c", "dense_matrix_r", "fixed_mutator_a", "fixed_mutator_c", "fixed_mutator_r", "four_col_matrix_r", "four_row_matrix_r", "get_matrix_int", "get_vector_float64", "sparse_matrix_c", "sparse_matrix_r", ] def accept_matrix_int( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.int32, "[3, 3]"], ) -> None: ... def accept_vector_float64( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, "[3, 1]"], ) -> None: ... def dense_matrix_c( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.float32, "[m, n]"], ) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[m, n]"]: ... def dense_matrix_r( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.float32, "[m, n]"], ) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[m, n]"]: ... def fixed_mutator_a( arg0: typing.Annotated[ numpy.typing.NDArray[numpy.float32], "[5, 6]", "flags.writeable" ], ) -> None: ... def fixed_mutator_c( arg0: typing.Annotated[ numpy.typing.NDArray[numpy.float32], "[5, 6]", "flags.writeable", "flags.f_contiguous", ], ) -> None: ... def fixed_mutator_r( arg0: typing.Annotated[ numpy.typing.NDArray[numpy.float32], "[5, 6]", "flags.writeable", "flags.c_contiguous", ], ) -> None: ... def four_col_matrix_r( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.float32, "[m, 4]"], ) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[m, 4]"]: ... def four_row_matrix_r( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.float32, "[4, n]"], ) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, n]"]: ... def get_matrix_int() -> typing.Annotated[ numpy.typing.NDArray[numpy.int32], "[3, 3]" ]: ... def get_vector_float64() -> typing.Annotated[ numpy.typing.NDArray[numpy.float64], "[3, 1]" ]: ... def sparse_matrix_c(arg0: scipy.sparse.csc_matrix) -> scipy.sparse.csc_matrix: ... def sparse_matrix_r(arg0: scipy.sparse.csr_matrix) -> scipy.sparse.csr_matrix: ... enum.pyi000066400000000000000000000044021525537303700360740ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "Blue", "ConsoleForegroundColor", "Green", "Magenta", "None_", "Yellow", "accept_defaulted_enum", ] class ConsoleForegroundColor: """ Members: Green Yellow Blue Magenta None_ """ Blue: typing.ClassVar[ ConsoleForegroundColor ] # value = Green: typing.ClassVar[ ConsoleForegroundColor ] # value = Magenta: typing.ClassVar[ ConsoleForegroundColor ] # value = None_: typing.ClassVar[ ConsoleForegroundColor ] # value = Yellow: typing.ClassVar[ ConsoleForegroundColor ] # value = __members__: typing.ClassVar[ dict[str, ConsoleForegroundColor] ] # value = {'Green': , 'Yellow': , 'Blue': , 'Magenta': , 'None_': } def __eq__(self, other: typing.Any) -> bool: ... def __getstate__(self) -> int: ... def __hash__(self) -> int: ... def __index__(self) -> int: ... def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None: ... def __int__(self) -> int: ... def __ne__(self, other: typing.Any) -> bool: ... def __repr__(self) -> str: ... def __setstate__( self, state: typing.SupportsInt | typing.SupportsIndex ) -> None: ... def __str__(self) -> str: ... @property def name(self) -> str: ... @property def value(self) -> int: ... def accept_defaulted_enum( color: ConsoleForegroundColor = ConsoleForegroundColor.None_, ) -> None: ... Blue: ConsoleForegroundColor # value = Green: ConsoleForegroundColor # value = Magenta: ConsoleForegroundColor # value = None_: ConsoleForegroundColor # value = Yellow: ConsoleForegroundColor # value = flawed_bindings.pyi000066400000000000000000000011461525537303700402510ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "Enum", "Unbound", "accept_unbound_enum", "accept_unbound_enum_defaulted", "accept_unbound_type", "accept_unbound_type_defaulted", "get_unbound_type", ] class Unbound: pass class Enum: pass def accept_unbound_enum(arg0: ...) -> int: ... def accept_unbound_enum_defaulted(x: Enum = ...) -> int: ... def accept_unbound_type( arg0: tuple[..., typing.SupportsInt | typing.SupportsIndex], ) -> int: ... def accept_unbound_type_defaulted(x: Unbound = ...) -> int: ... def get_unbound_type() -> ...: ... functions.pyi000066400000000000000000000066631525537303700371530ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import collections.abc import typing __all__: list[str] = [ "Foo", "U", "accept_annotated_callable", "accept_callable", "accept_frozenset", "accept_py_handle", "accept_py_object", "accept_set", "add", "default_custom_arg", "default_int_arg", "default_list_arg", "default_optional_arg", "func_w_anon_args", "func_w_named_pos_args", "generic", "mul", "nested_types", "pass_callback", "passthrough1", "passthrough2", "passthrough3", "passthrough_backwards", "pos_kw_only_mix", "pos_kw_only_variadic_mix", ] class Foo: def __init__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None: ... def accept_annotated_callable( arg0: collections.abc.Callable[ [ typing.SupportsInt | typing.SupportsIndex, typing.SupportsInt | typing.SupportsIndex, ], int, ], ) -> typing.Any: ... def accept_callable(arg0: collections.abc.Callable) -> typing.Any: ... def accept_frozenset(arg0: frozenset) -> None: ... def accept_py_handle(arg0: typing.Any) -> str: ... def accept_py_object(arg0: typing.Any) -> str: ... def accept_set(arg0: set) -> None: ... def add( arg0: typing.SupportsInt | typing.SupportsIndex, arg1: typing.SupportsInt | typing.SupportsIndex, ) -> int: ... def default_custom_arg(foo: Foo = Foo(5)) -> None: ... def default_int_arg(n: typing.SupportsInt | typing.SupportsIndex = 5) -> None: ... def default_list_arg(l: list = [1, 2, 6, 18]) -> None: ... def default_optional_arg( n: typing.SupportsInt | typing.SupportsIndex | None = None, ) -> None: ... def func_w_anon_args( arg0: typing.SupportsInt | typing.SupportsIndex, arg1: typing.SupportsInt | typing.SupportsIndex, arg2: typing.SupportsInt | typing.SupportsIndex, ) -> None: ... def func_w_named_pos_args( x: typing.SupportsInt | typing.SupportsIndex, y: typing.SupportsInt | typing.SupportsIndex, z: typing.SupportsInt | typing.SupportsIndex, ) -> None: ... def generic(*args, **kwargs) -> None: ... @typing.overload def mul( x: typing.SupportsInt | typing.SupportsIndex, y: typing.SupportsInt | typing.SupportsIndex, ) -> int: """ Multiply x and y (int) """ @typing.overload def mul( p: typing.SupportsFloat | typing.SupportsIndex, q: typing.SupportsFloat | typing.SupportsIndex, ) -> float: """ Multiply p and q (double) """ def nested_types(arg0: collections.abc.Sequence[Foo] | Foo) -> list[Foo] | Foo: ... def pass_callback(arg0: collections.abc.Callable[[Foo], Foo]) -> Foo: ... def passthrough1(*args, **kwargs): """ passthrough1[T](obj: T) -> T """ @typing.overload def passthrough2() -> None: """ 2. passthrough2[T](obj: T) -> T """ @typing.overload def passthrough3() -> tuple[None, None]: """ 2. passthrough3[T](obj: T) -> tuple[T, None] 3. passthrough3[T1, T2](obj1: T1, obj2: T2) -> tuple[T1, T2] """ def passthrough_backwards(obj: U) -> U: ... def pos_kw_only_mix( i: typing.SupportsInt | typing.SupportsIndex, /, j: typing.SupportsInt | typing.SupportsIndex, *, k: typing.SupportsInt | typing.SupportsIndex, ) -> tuple: ... def pos_kw_only_variadic_mix( i: typing.SupportsInt | typing.SupportsIndex, /, j: typing.SupportsInt | typing.SupportsIndex, *args, k: typing.SupportsInt | typing.SupportsIndex, **kwargs, ) -> tuple: ... U: typing.TypeVar # value = ~U issues.pyi000066400000000000000000000022041525537303700364410ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "backslashes_should_be_escaped", "issue_51_catastrophic_regex", "issue_73_utf8_doc_chars", "issue_274_docstring_leading_newline", ] def backslashes_should_be_escaped() -> None: """ \\brief A brief description of this function. A detailed description of this function. Here's some reStructuredText: :math:`x = [x, y, \\theta]^T` """ def issue_274_docstring_leading_newline() -> None: """ This is a docstring """ def issue_51_catastrophic_regex( arg0: typing.SupportsInt | typing.SupportsIndex, arg1: typing.SupportsInt ) -> None: """ Use-case: issue_51(os.get_handle_inheritable, os.set_handle_inheritable) """ def issue_73_utf8_doc_chars() -> None: """ Construct a Ramsete unicycle controller. Tuning parameter (b > 0 rad²/m²) for which larger values make convergence more aggressive like a proportional term. Tuning parameter (0 rad⁻¹ < zeta < 1 rad⁻¹) for which larger values provide more damping in response. """ _cleanup: typing.Any # value = methods.pyi000066400000000000000000000004551525537303700365770ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = ["Dummy"] class Dummy: @staticmethod def static_method(arg0: typing.SupportsInt | typing.SupportsIndex) -> int: ... def regular_method( self, arg0: typing.SupportsInt | typing.SupportsIndex ) -> int: ... numpy.pyi000066400000000000000000000011741525537303700363030ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import typing import numpy import numpy.typing __all__: list[str] = [ "accept_ndarray_float64", "accept_ndarray_int", "get_ndarray_float64", "get_ndarray_int", "return_dtype", ] def accept_ndarray_float64( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.float64], ) -> None: ... def accept_ndarray_int( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.int32], ) -> None: ... def get_ndarray_float64() -> numpy.typing.NDArray[numpy.float64]: ... def get_ndarray_int() -> numpy.typing.NDArray[numpy.int32]: ... def return_dtype() -> numpy.dtype[typing.Any]: ... properties.pyi000066400000000000000000000055021525537303700373260ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "WithGetterSetterDoc", "WithPropAndGetterSetterDoc", "WithPropDoc", "WithoutDoc", ] class WithoutDoc: """ No user docstring provided """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 @property def def_property(self) -> int: ... @def_property.setter def def_property(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None: ... @property def def_property_readonly(self) -> int: ... @property def def_readonly(self) -> int: ... @property def def_readwrite(self) -> int: ... @def_readwrite.setter def def_readwrite( self, arg0: typing.SupportsInt | typing.SupportsIndex ) -> None: ... class WithPropDoc: """ User docstring provided only to `def_` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 @property def def_property(self) -> int: """ prop doc token """ @def_property.setter def def_property(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None: ... @property def def_property_readonly(self) -> int: """ prop doc token """ @property def def_readonly(self) -> int: """ prop doc token """ @property def def_readwrite(self) -> int: """ prop doc token """ @def_readwrite.setter def def_readwrite( self, arg0: typing.SupportsInt | typing.SupportsIndex ) -> None: ... class WithGetterSetterDoc: """ User docstring provided via pybind11::cpp_function(..., doc) to getters/setters, but NOT to `def_*(..., doc)` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 @property def def_property(self) -> int: """ getter doc token """ @def_property.setter def def_property(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None: """ setter doc token """ @property def def_property_readonly(self) -> int: """ getter doc token """ class WithPropAndGetterSetterDoc: """ User docstring provided via pybind11::cpp_function(..., doc) to getters/setters and to `def_*(, doc)` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 @property def def_property(self) -> int: """ prop doc token """ @def_property.setter def def_property(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None: ... @property def def_property_readonly(self) -> int: """ prop doc token """ stl.pyi000066400000000000000000000015561525537303700357410ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import collections.abc import typing __all__: list[str] = [ "std_array", "std_map", "std_optional", "std_variant", "std_vector", ] def std_array( arg0: typing.Annotated[ collections.abc.Sequence[typing.SupportsInt | typing.SupportsIndex], "FixedSize(3)", ], ) -> typing.Annotated[list[int], "FixedSize(3)"]: ... def std_map() -> dict[int, complex]: ... def std_optional(arg0: typing.SupportsInt | typing.SupportsIndex | None) -> None: ... def std_variant( arg0: ( typing.SupportsInt | typing.SupportsIndex | typing.SupportsFloat | typing.SupportsIndex | tuple[ typing.SupportsInt | typing.SupportsIndex, typing.SupportsInt | typing.SupportsIndex, ] ), ) -> None: ... def std_vector() -> list[tuple[int, float]]: ... stl_bind.pyi000066400000000000000000000110471525537303700367310ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import collections.abc import typing __all__: list[str] = [ "MapStringComplex", "VectorPairStringDouble", "get_complex_map", "get_vector_of_pairs", ] class VectorPairStringDouble: __hash__: typing.ClassVar[None] = None def __bool__(self) -> bool: """ Check whether the list is nonempty """ def __contains__( self, x: tuple[str, typing.SupportsFloat | typing.SupportsIndex] ) -> bool: """ Return true the container contains ``x`` """ @typing.overload def __delitem__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None: """ Delete the list elements at index ``i`` """ @typing.overload def __delitem__(self, arg0: slice) -> None: """ Delete list elements using a slice object """ def __eq__(self, arg0: VectorPairStringDouble) -> bool: ... @typing.overload def __getitem__(self, s: slice) -> VectorPairStringDouble: """ Retrieve list elements using a slice object """ @typing.overload def __getitem__( self, arg0: typing.SupportsInt | typing.SupportsIndex ) -> tuple[str, float]: ... @typing.overload def __init__(self) -> None: ... @typing.overload def __init__(self, arg0: VectorPairStringDouble) -> None: """ Copy constructor """ @typing.overload def __init__(self, arg0: collections.abc.Iterable) -> None: ... def __iter__(self) -> collections.abc.Iterator[tuple[str, float]]: ... def __len__(self) -> int: ... def __ne__(self, arg0: VectorPairStringDouble) -> bool: ... @typing.overload def __setitem__( self, arg0: typing.SupportsInt | typing.SupportsIndex, arg1: tuple[str, typing.SupportsFloat | typing.SupportsIndex], ) -> None: ... @typing.overload def __setitem__(self, arg0: slice, arg1: VectorPairStringDouble) -> None: """ Assign list elements using a slice object """ def append( self, x: tuple[str, typing.SupportsFloat | typing.SupportsIndex] ) -> None: """ Add an item to the end of the list """ def clear(self) -> None: """ Clear the contents """ def count(self, x: tuple[str, typing.SupportsFloat | typing.SupportsIndex]) -> int: """ Return the number of times ``x`` appears in the list """ @typing.overload def extend(self, L: VectorPairStringDouble) -> None: """ Extend the list by appending all the items in the given list """ @typing.overload def extend(self, L: collections.abc.Iterable) -> None: """ Extend the list by appending all the items in the given list """ def insert( self, i: typing.SupportsInt | typing.SupportsIndex, x: tuple[str, typing.SupportsFloat | typing.SupportsIndex], ) -> None: """ Insert an item at a given position. """ @typing.overload def pop(self) -> tuple[str, float]: """ Remove and return the last item """ @typing.overload def pop(self, i: typing.SupportsInt | typing.SupportsIndex) -> tuple[str, float]: """ Remove and return the item at index ``i`` """ def remove( self, x: tuple[str, typing.SupportsFloat | typing.SupportsIndex] ) -> None: """ Remove the first item from the list whose value is x. It is an error if there is no such item. """ class MapStringComplex: def __bool__(self) -> bool: """ Check whether the map is nonempty """ @typing.overload def __contains__(self, arg0: str) -> bool: ... @typing.overload def __contains__(self, arg0: typing.Any) -> bool: ... def __delitem__(self, arg0: str) -> None: ... def __getitem__(self, arg0: str) -> complex: ... def __init__(self) -> None: ... def __iter__(self) -> collections.abc.Iterator[str]: ... def __len__(self) -> int: ... def __repr__(self) -> str: """ Return the canonical string representation of this map. """ def __setitem__( self, arg0: str, arg1: typing.SupportsComplex | typing.SupportsFloat | typing.SupportsIndex, ) -> None: ... def items(self) -> typing.ItemsView: ... def keys(self) -> typing.KeysView: ... def values(self) -> typing.ValuesView: ... def get_complex_map() -> MapStringComplex: ... def get_vector_of_pairs() -> VectorPairStringDouble: ... typing.pyi000066400000000000000000000004551525537303700364460ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import collections.abc import typing_extensions __all__: list[str] = ["get_buffer", "get_sequence"] def get_buffer(arg0: typing_extensions.Buffer) -> typing_extensions.Buffer: ... def get_sequence(arg0: collections.abc.Sequence) -> collections.abc.Sequence: ... values.pyi000066400000000000000000000014521525537303700364310ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import datetime import numpy from numpy import random __all__: list[str] = [ "Dummy", "Foo", "add_day", "foolist", "foovar", "list_with_none", "none", "random", "t_10ms", "t_20ns", "t_30s", ] class Dummy: linalg = numpy.linalg class Foo: pass def add_day(arg0: datetime.datetime) -> datetime.datetime: ... foolist: list # value = [, ] foovar: Foo # value = list_with_none: list = [None, 2, {}] none = None t_10ms: datetime.timedelta # value = datetime.timedelta(microseconds=10000) t_20ns: datetime.timedelta # value = datetime.timedelta(0) t_30s: datetime.timedelta # value = datetime.timedelta(seconds=30) core.pyi000066400000000000000000000007451525537303700341320ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-use-type-var/demofrom __future__ import annotations from demo._bindings import ( aliases, classes, eigen, enum, flawed_bindings, functions, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) __all__: list[str] = [ "aliases", "classes", "eigen", "enum", "flawed_bindings", "functions", "issues", "methods", "numpy", "properties", "stl", "stl_bind", "typing", "values", ] pure_python/000077500000000000000000000000001525537303700350255ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-use-type-var/demo__init__.pyi000066400000000000000000000003611525537303700373070ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-use-type-var/demo/pure_pythonfrom __future__ import annotations from . import classes, functions, functions_3_8_plus, functions_3_9_plus, values __all__: list[str] = [ "classes", "functions", "functions_3_8_plus", "functions_3_9_plus", "values", ] classes.pyi000066400000000000000000000003071525537303700372050ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-use-type-var/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["A", "B", "C", "X"] class A: """ A """ class B(A): """ B """ class C(B): """ C """ class X: pass functions.pyi000066400000000000000000000015561525537303700375670ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-use-type-var/demo/pure_pythonfrom __future__ import annotations import sys as sys import typing as typing from demo.pure_python.functions_3_8_plus import args_mix from demo.pure_python.functions_3_9_plus import generic_alias_annotation __all__: list[str] = [ "accept_frozenset", "args_mix", "builtin_function_as_default_arg", "function_as_default_arg", "generic_alias_annotation", "lambda_as_default_arg", "search", "static_method_as_default_arg", "sys", "typing", ] class _Dummy: @staticmethod def foo(): ... def accept_frozenset(arg: frozenset[int | float]) -> int | None: ... def builtin_function_as_default_arg(func: type(len) = len): ... def function_as_default_arg(func: type(search) = search): ... def lambda_as_default_arg(callback=...): ... def search(a: int, b: list[int]) -> int: ... def static_method_as_default_arg(callback=_Dummy.foo): ... functions_3_8_plus.pyi000066400000000000000000000007761525537303700413060ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-use-type-var/demo/pure_pythonfrom __future__ import annotations import typing as typing __all__: list[str] = [ "Expression", "Token", "args_mix", "nested_current_module_annotations", "typing", ] class Token: pass class Expression: pass def args_mix( a: int, b: float = 0.5, c: str = "", *args: int, x: int = 1, y=int, **kwargs: dict[int, str], ): ... def nested_current_module_annotations( tokens: list[Token], expr: Expression | None = None ) -> dict[str, Expression]: ... functions_3_9_plus.pyi000066400000000000000000000002601525537303700412730ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-use-type-var/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["generic_alias_annotation"] def generic_alias_annotation(a: list[tuple[int]], b: dict[int, str]) -> list[float]: ... values.pyi000066400000000000000000000001741525537303700370510ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-use-type-var/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["callables_dict"] callables_dict: dict = {"len": len, "int": int} numpy-array-wrap-with-annotated/000077500000000000000000000000001525537303700330615ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0demo/000077500000000000000000000000001525537303700340055ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-wrap-with-annotated__init__.pyi000066400000000000000000000012021525537303700362620ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-wrap-with-annotated/demofrom __future__ import annotations from demo._bindings import ( aliases, classes, eigen, enum, flawed_bindings, functions, hidden_builtins, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) from . import _bindings, core, pure_python __all__: list[str] = [ "aliases", "classes", "core", "eigen", "enum", "flawed_bindings", "functions", "hidden_builtins", "issues", "methods", "numpy", "properties", "pure_python", "stl", "stl_bind", "typing", "values", "version", ] version: str = "0.0.0" _bindings/000077500000000000000000000000001525537303700357415ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-wrap-with-annotated/demo__init__.pyi000066400000000000000000000010041525537303700402160ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations from . import ( aliases, classes, eigen, enum, flawed_bindings, functions, hidden_builtins, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) __all__: list[str] = [ "aliases", "classes", "eigen", "enum", "flawed_bindings", "functions", "hidden_builtins", "issues", "methods", "numpy", "properties", "stl", "stl_bind", "typing", "values", ] aliases/000077500000000000000000000000001525537303700373625ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindings__init__.pyi000066400000000000000000000021441525537303700416450ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import typing import demo._bindings.enum import numpy from demo._bindings.aliases.foreign_method_arg import Bar2 as foreign_type_alias from demo._bindings.aliases.foreign_return import get_foo as foreign_class_alias from numpy import random from . import ( foreign_arg, foreign_attr, foreign_class_member, foreign_method_arg, foreign_method_return, foreign_return, missing_self_arg, ) __all__: list[str] = [ "Color", "Dummy", "foreign_arg", "foreign_attr", "foreign_class_alias", "foreign_class_member", "foreign_enum_default", "foreign_method_arg", "foreign_method_return", "foreign_return", "foreign_type_alias", "func", "local_func_alias", "local_type_alias", "missing_self_arg", "random", ] class Dummy: linalg = numpy.linalg class Color: pass def foreign_enum_default( color: typing.Any = demo._bindings.enum.ConsoleForegroundColor.Blue, ) -> None: ... def func(arg0: typing.SupportsInt | typing.SupportsIndex) -> int: ... local_type_alias = Color local_func_alias = func foreign_arg.pyi000066400000000000000000000002371525537303700423710ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["set_foo"] def set_foo(arg0: demo._bindings.classes.Foo) -> int: ... foreign_attr.pyi000066400000000000000000000002631525537303700425710ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["value"] value: demo._bindings.classes.Foo # value = foreign_class_member.pyi000066400000000000000000000003571525537303700442570ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import typing import demo._bindings.classes __all__: list[str] = ["Bar1"] class Bar1: foo: typing.ClassVar[ demo._bindings.classes.Foo ] # value = foreign_method_arg.pyi000066400000000000000000000002621525537303700437270ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar2"] class Bar2: def set_foo(self, arg0: demo._bindings.classes.Foo) -> int: ... foreign_method_return.pyi000066400000000000000000000002651525537303700445000ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar3"] class Bar3: @staticmethod def get_foo() -> demo._bindings.classes.Foo: ... foreign_return.pyi000066400000000000000000000002261525537303700431350ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["get_foo"] def get_foo() -> demo._bindings.classes.Foo: ... missing_self_arg.pyi000066400000000000000000000002541525537303700434210ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar4"] class Bar4: def set_foo(self: demo._bindings.classes.Foo) -> int: ... classes.pyi000066400000000000000000000046021525537303700401230ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "CppException", "Derived", "Foo", "MyBase", "Outer", "ParIter", "ParIterBase", "ParticleContainer", ] class Outer: class Inner: class NestedEnum: """ Members: ONE TWO """ ONE: typing.ClassVar[Outer.Inner.NestedEnum] # value = TWO: typing.ClassVar[Outer.Inner.NestedEnum] # value = __members__: typing.ClassVar[ dict[str, Outer.Inner.NestedEnum] ] # value = {'ONE': , 'TWO': } def __eq__(self, other: typing.Any) -> bool: ... def __getstate__(self) -> int: ... def __hash__(self) -> int: ... def __index__(self) -> int: ... def __init__( self, value: typing.SupportsInt | typing.SupportsIndex ) -> None: ... def __int__(self) -> int: ... def __ne__(self, other: typing.Any) -> bool: ... def __repr__(self) -> str: ... def __setstate__( self, state: typing.SupportsInt | typing.SupportsIndex ) -> None: ... def __str__(self) -> str: ... @property def name(self) -> str: ... @property def value(self) -> int: ... value: Outer.Inner.NestedEnum inner: Outer.Inner class MyBase: class Inner: pass name: str class Derived(MyBase): @property def count(self) -> int: ... @count.setter def count(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None: ... class Foo: class FooChild: def __init__(self) -> None: ... def g(self) -> None: ... def __init__(self) -> None: ... def f(self) -> None: ... class ParIterBase: @property def level(self) -> int: ... @level.setter def level(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None: ... class ParIter(ParIterBase): def __init__( self, particle_container: ParticleContainer, level: typing.SupportsInt | typing.SupportsIndex, ) -> None: ... class ParticleContainer: name: str Iterator = ParIter def process(self, arg0: ParIter) -> None: ... class CppException(Exception): pass eigen.pyi000066400000000000000000000045421525537303700375600ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing import numpy import numpy.typing import scipy.sparse __all__: list[str] = [ "accept_matrix_int", "accept_vector_float64", "dense_matrix_c", "dense_matrix_r", "fixed_mutator_a", "fixed_mutator_c", "fixed_mutator_r", "four_col_matrix_r", "four_row_matrix_r", "get_matrix_int", "get_vector_float64", "sparse_matrix_c", "sparse_matrix_r", ] def accept_matrix_int( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.int32, "[3, 3]"], ) -> None: ... def accept_vector_float64( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, "[3, 1]"], ) -> None: ... def dense_matrix_c( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.float32, "[m, n]"], ) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[m, n]"]: ... def dense_matrix_r( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.float32, "[m, n]"], ) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[m, n]"]: ... def fixed_mutator_a( arg0: typing.Annotated[ numpy.typing.NDArray[numpy.float32], "[5, 6]", "flags.writeable" ], ) -> None: ... def fixed_mutator_c( arg0: typing.Annotated[ numpy.typing.NDArray[numpy.float32], "[5, 6]", "flags.writeable", "flags.f_contiguous", ], ) -> None: ... def fixed_mutator_r( arg0: typing.Annotated[ numpy.typing.NDArray[numpy.float32], "[5, 6]", "flags.writeable", "flags.c_contiguous", ], ) -> None: ... def four_col_matrix_r( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.float32, "[m, 4]"], ) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[m, 4]"]: ... def four_row_matrix_r( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.float32, "[4, n]"], ) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, n]"]: ... def get_matrix_int() -> typing.Annotated[ numpy.typing.NDArray[numpy.int32], "[3, 3]" ]: ... def get_vector_float64() -> typing.Annotated[ numpy.typing.NDArray[numpy.float64], "[3, 1]" ]: ... def sparse_matrix_c( arg0: typing.Annotated[scipy.sparse.csc_matrix, numpy.float32], ) -> typing.Annotated[scipy.sparse.csc_matrix, numpy.float32]: ... def sparse_matrix_r( arg0: typing.Annotated[scipy.sparse.csr_matrix, numpy.float32], ) -> typing.Annotated[scipy.sparse.csr_matrix, numpy.float32]: ... enum.pyi000066400000000000000000000050561525537303700374360ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import enum import typing __all__: list[str] = [ "Blue", "ConsoleForegroundColor", "Green", "Magenta", "NativeColor", "None_", "Yellow", "accept_defaulted_enum", ] class ConsoleForegroundColor: """ Members: Green Yellow Blue Magenta None_ """ Blue: typing.ClassVar[ ConsoleForegroundColor ] # value = Green: typing.ClassVar[ ConsoleForegroundColor ] # value = Magenta: typing.ClassVar[ ConsoleForegroundColor ] # value = None_: typing.ClassVar[ ConsoleForegroundColor ] # value = Yellow: typing.ClassVar[ ConsoleForegroundColor ] # value = __members__: typing.ClassVar[ dict[str, ConsoleForegroundColor] ] # value = {'Green': , 'Yellow': , 'Blue': , 'Magenta': , 'None_': } def __eq__(self, other: typing.Any) -> bool: ... def __getstate__(self) -> int: ... def __hash__(self) -> int: ... def __index__(self) -> int: ... def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None: ... def __int__(self) -> int: ... def __ne__(self, other: typing.Any) -> bool: ... def __repr__(self) -> str: ... def __setstate__( self, state: typing.SupportsInt | typing.SupportsIndex ) -> None: ... def __str__(self) -> str: ... @property def name(self) -> str: ... @property def value(self) -> int: ... class NativeColor(enum.IntEnum): Blue: typing.ClassVar[NativeColor] # value = Red: typing.ClassVar[NativeColor] # value = @classmethod def __new__(cls, value): ... def __format__(self, format_spec): ... def accept_defaulted_enum( color: ConsoleForegroundColor = ConsoleForegroundColor.None_, ) -> None: ... Blue: ConsoleForegroundColor # value = Green: ConsoleForegroundColor # value = Magenta: ConsoleForegroundColor # value = None_: ConsoleForegroundColor # value = Yellow: ConsoleForegroundColor # value = flawed_bindings.pyi000066400000000000000000000011461525537303700416050ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "Enum", "Unbound", "accept_unbound_enum", "accept_unbound_enum_defaulted", "accept_unbound_type", "accept_unbound_type_defaulted", "get_unbound_type", ] class Unbound: pass class Enum: pass def accept_unbound_enum(arg0: ...) -> int: ... def accept_unbound_enum_defaulted(x: Enum = ...) -> int: ... def accept_unbound_type( arg0: tuple[..., typing.SupportsInt | typing.SupportsIndex], ) -> int: ... def accept_unbound_type_defaulted(x: Unbound = ...) -> int: ... def get_unbound_type() -> ...: ... functions.pyi000066400000000000000000000067211525537303700405020ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import collections.abc import typing __all__: list[str] = [ "Foo", "U", "accept_annotated_callable", "accept_callable", "accept_frozenset", "accept_py_handle", "accept_py_object", "accept_set", "add", "default_custom_arg", "default_int_arg", "default_list_arg", "default_optional_arg", "func_w_anon_args", "func_w_named_pos_args", "generic", "mul", "nested_types", "pass_callback", "passthrough1", "passthrough2", "passthrough3", "passthrough_backwards", "pos_kw_only_mix", "pos_kw_only_variadic_mix", ] class Foo: def __init__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None: ... def accept_annotated_callable( arg0: collections.abc.Callable[ [ typing.SupportsInt | typing.SupportsIndex, typing.SupportsInt | typing.SupportsIndex, ], int, ], ) -> typing.Any: ... def accept_callable(arg0: collections.abc.Callable) -> typing.Any: ... def accept_frozenset(arg0: frozenset) -> None: ... def accept_py_handle(arg0: typing.Any) -> str: ... def accept_py_object(arg0: typing.Any) -> str: ... def accept_set(arg0: set) -> None: ... def add( arg0: typing.SupportsInt | typing.SupportsIndex, arg1: typing.SupportsInt | typing.SupportsIndex, ) -> int: ... def default_custom_arg(foo: Foo = Foo(5)) -> None: ... def default_int_arg(n: typing.SupportsInt | typing.SupportsIndex = 5) -> None: ... def default_list_arg(l: list = [1, 2, 6, 18]) -> None: ... def default_optional_arg( n: typing.SupportsInt | typing.SupportsIndex | None = None, ) -> None: ... def func_w_anon_args( arg0: typing.SupportsInt | typing.SupportsIndex, arg1: typing.SupportsInt | typing.SupportsIndex, arg2: typing.SupportsInt | typing.SupportsIndex, ) -> None: ... def func_w_named_pos_args( x: typing.SupportsInt | typing.SupportsIndex, y: typing.SupportsInt | typing.SupportsIndex, z: typing.SupportsInt | typing.SupportsIndex, ) -> None: ... def generic(*args, **kwargs) -> None: ... @typing.overload def mul( x: typing.SupportsInt | typing.SupportsIndex, y: typing.SupportsInt | typing.SupportsIndex, ) -> int: """ Multiply x and y (int) """ @typing.overload def mul( p: typing.SupportsFloat | typing.SupportsIndex, q: typing.SupportsFloat | typing.SupportsIndex, ) -> float: """ Multiply p and q (double) """ def nested_types(arg0: collections.abc.Sequence[Foo] | Foo) -> list[Foo] | Foo: ... def pass_callback(arg0: collections.abc.Callable[[Foo], Foo]) -> Foo: ... def passthrough1(*args, **kwargs): """ passthrough1[T](obj: T) -> T """ @typing.overload def passthrough2() -> None: """ 2. passthrough2[T](obj: T) -> T """ @typing.overload def passthrough3() -> tuple[None, None]: """ 2. passthrough3[T](obj: T) -> tuple[T, None] 3. passthrough3[T1, T2](obj1: T1, obj2: T2) -> tuple[T1, T2] """ def passthrough_backwards(obj: U) -> U: ... def pos_kw_only_mix( i: typing.SupportsInt | typing.SupportsIndex, /, j: typing.SupportsInt | typing.SupportsIndex, *, k: typing.SupportsInt | typing.SupportsIndex, ) -> tuple[int, int, int]: ... def pos_kw_only_variadic_mix( i: typing.SupportsInt | typing.SupportsIndex, /, j: typing.SupportsInt | typing.SupportsIndex, *args, k: typing.SupportsInt | typing.SupportsIndex, **kwargs, ) -> tuple[int, int, int]: ... U: typing.TypeVar # value = ~U hidden_builtins.pyi000066400000000000000000000002571525537303700416340ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import types __all__: list[str] = ["mapping_proxy", "none"] mapping_proxy: types.MappingProxyType # value = mappingproxy({}) none = None issues.pyi000066400000000000000000000022401525537303700377750ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "backslashes_should_be_escaped", "issue_51_catastrophic_regex", "issue_73_utf8_doc_chars", "issue_274_docstring_leading_newline", ] def backslashes_should_be_escaped() -> None: """ \\brief A brief description of this function. A detailed description of this function. Here's some reStructuredText: :math:`x = [x, y, \\theta]^T` """ def issue_274_docstring_leading_newline() -> None: """ This is a docstring """ def issue_51_catastrophic_regex( arg0: typing.SupportsInt | typing.SupportsIndex, arg1: typing.SupportsInt | typing.SupportsIndex, ) -> None: """ Use-case: issue_51(os.get_handle_inheritable, os.set_handle_inheritable) """ def issue_73_utf8_doc_chars() -> None: """ Construct a Ramsete unicycle controller. Tuning parameter (b > 0 rad²/m²) for which larger values make convergence more aggressive like a proportional term. Tuning parameter (0 rad⁻¹ < zeta < 1 rad⁻¹) for which larger values provide more damping in response. """ _cleanup: typing.Any # value = methods.pyi000066400000000000000000000004551525537303700401330ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = ["Dummy"] class Dummy: @staticmethod def static_method(arg0: typing.SupportsInt | typing.SupportsIndex) -> int: ... def regular_method( self, arg0: typing.SupportsInt | typing.SupportsIndex ) -> int: ... numpy.pyi000066400000000000000000000011741525537303700376370ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing import numpy import numpy.typing __all__: list[str] = [ "accept_ndarray_float64", "accept_ndarray_int", "get_ndarray_float64", "get_ndarray_int", "return_dtype", ] def accept_ndarray_float64( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.float64], ) -> None: ... def accept_ndarray_int( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.int32], ) -> None: ... def get_ndarray_float64() -> numpy.typing.NDArray[numpy.float64]: ... def get_ndarray_int() -> numpy.typing.NDArray[numpy.int32]: ... def return_dtype() -> numpy.dtype[typing.Any]: ... properties.pyi000066400000000000000000000054731525537303700406710ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "WithGetterSetterDoc", "WithPropAndGetterSetterDoc", "WithPropDoc", "WithoutDoc", ] class WithoutDoc: """ No user docstring provided """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 @property def def_property(self) -> int: ... @def_property.setter def def_property(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None: ... @property def def_property_readonly(self) -> int: ... @property def def_readonly(self) -> int: ... @property def def_readwrite(self) -> int: ... @def_readwrite.setter def def_readwrite( self, arg0: typing.SupportsInt | typing.SupportsIndex ) -> None: ... class WithPropDoc: """ User docstring provided only to `def_` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 @property def def_property(self) -> int: """ prop doc token """ @def_property.setter def def_property(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None: ... @property def def_property_readonly(self) -> int: """ prop doc token """ @property def def_readonly(self) -> int: """ prop doc token """ @property def def_readwrite(self) -> int: """ prop doc token """ @def_readwrite.setter def def_readwrite( self, arg0: typing.SupportsInt | typing.SupportsIndex ) -> None: ... class WithGetterSetterDoc: """ User docstring provided via pybind11::cpp_function(..., doc) to getters/setters, but NOT to `def_*(..., doc)` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 @property def def_property(self) -> int: """ getter doc token """ @def_property.setter def def_property(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None: """ setter doc token """ @property def def_property_readonly(self) -> int: """ getter doc token """ class WithPropAndGetterSetterDoc: """ User docstring provided via pybind11::cpp_function(..., doc) to getters/setters and to `def_*(, doc)` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 @property def def_property(self) -> int: """ prop doc token """ @def_property.setter def def_property(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None: ... @property def def_property_readonly(self) -> int: """ prop doc token """ stl.pyi000066400000000000000000000015021525537303700372640ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import collections.abc import typing __all__: list[str] = [ "std_array", "std_map", "std_optional", "std_variant", "std_vector", ] def std_array( arg0: typing.Annotated[ collections.abc.Sequence[typing.SupportsInt | typing.SupportsIndex], "FixedSize(3)", ], ) -> typing.Annotated[list[int], "FixedSize(3)"]: ... def std_map() -> dict[int, complex]: ... def std_optional(arg0: typing.SupportsInt | typing.SupportsIndex | None) -> None: ... def std_variant( arg0: typing.SupportsInt | typing.SupportsIndex | typing.SupportsFloat | typing.SupportsIndex | tuple[ typing.SupportsInt | typing.SupportsIndex, typing.SupportsInt | typing.SupportsIndex, ], ) -> None: ... def std_vector() -> list[tuple[int, float]]: ... stl_bind.pyi000066400000000000000000000110261525537303700402620ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import collections.abc import typing __all__: list[str] = [ "MapStringComplex", "VectorPairStringDouble", "get_complex_map", "get_vector_of_pairs", ] class VectorPairStringDouble: __hash__: typing.ClassVar[None] = None def __bool__(self) -> bool: """ Check whether the list is nonempty """ def __contains__( self, x: tuple[str, typing.SupportsFloat | typing.SupportsIndex] ) -> bool: """ Return true the container contains ``x`` """ @typing.overload def __delitem__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None: """ Delete the list elements at index ``i`` """ @typing.overload def __delitem__(self, arg0: slice) -> None: """ Delete list elements using a slice object """ def __eq__(self, arg0: VectorPairStringDouble) -> bool: ... @typing.overload def __getitem__(self, s: slice) -> VectorPairStringDouble: """ Retrieve list elements using a slice object """ @typing.overload def __getitem__( self, arg0: typing.SupportsInt | typing.SupportsIndex ) -> tuple[str, float]: ... @typing.overload def __init__(self) -> None: ... @typing.overload def __init__(self, arg0: VectorPairStringDouble) -> None: """ Copy constructor """ @typing.overload def __init__(self, arg0: collections.abc.Iterable) -> None: ... def __iter__(self) -> collections.abc.Iterator[tuple[str, float]]: ... def __len__(self) -> int: ... def __ne__(self, arg0: VectorPairStringDouble) -> bool: ... @typing.overload def __setitem__( self, arg0: typing.SupportsInt | typing.SupportsIndex, arg1: tuple[str, typing.SupportsFloat | typing.SupportsIndex], ) -> None: ... @typing.overload def __setitem__(self, arg0: slice, arg1: VectorPairStringDouble) -> None: """ Assign list elements using a slice object """ def append( self, x: tuple[str, typing.SupportsFloat | typing.SupportsIndex] ) -> None: """ Add an item to the end of the list """ def clear(self) -> None: """ Clear the contents """ def count(self, x: tuple[str, typing.SupportsFloat | typing.SupportsIndex]) -> int: """ Return the number of times ``x`` appears in the list """ @typing.overload def extend(self, L: VectorPairStringDouble) -> None: """ Extend the list by appending all the items in the given list """ @typing.overload def extend(self, L: collections.abc.Iterable) -> None: """ Extend the list by appending all the items in the given list """ def insert( self, i: typing.SupportsInt | typing.SupportsIndex, x: tuple[str, typing.SupportsFloat | typing.SupportsIndex], ) -> None: """ Insert an item at a given position. """ @typing.overload def pop(self) -> tuple[str, float]: """ Remove and return the last item """ @typing.overload def pop(self, i: typing.SupportsInt | typing.SupportsIndex) -> tuple[str, float]: """ Remove and return the item at index ``i`` """ def remove( self, x: tuple[str, typing.SupportsFloat | typing.SupportsIndex] ) -> None: """ Remove the first item from the list whose value is x. It is an error if there is no such item. """ class MapStringComplex: def __bool__(self) -> bool: """ Check whether the map is nonempty """ @typing.overload def __contains__(self, arg0: str) -> bool: ... @typing.overload def __contains__(self, arg0: typing.Any) -> bool: ... def __delitem__(self, arg0: str) -> None: ... def __getitem__(self, arg0: str) -> complex: ... def __init__(self) -> None: ... def __iter__(self) -> collections.abc.Iterator[str]: ... def __len__(self) -> int: ... def __repr__(self) -> str: """ Return the canonical string representation of this map. """ def __setitem__( self, arg0: str, arg1: typing.SupportsComplex | typing.SupportsFloat | typing.SupportsIndex, ) -> None: ... def items(self) -> typing.ItemsView: ... def keys(self) -> typing.KeysView: ... def values(self) -> typing.ValuesView: ... def get_complex_map() -> MapStringComplex: ... def get_vector_of_pairs() -> VectorPairStringDouble: ... typing.pyi000066400000000000000000000004551525537303700400020ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import collections.abc import typing_extensions __all__: list[str] = ["get_buffer", "get_sequence"] def get_buffer(arg0: typing_extensions.Buffer) -> typing_extensions.Buffer: ... def get_sequence(arg0: collections.abc.Sequence) -> collections.abc.Sequence: ... values.pyi000066400000000000000000000014521525537303700377650ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import datetime import numpy from numpy import random __all__: list[str] = [ "Dummy", "Foo", "add_day", "foolist", "foovar", "list_with_none", "none", "random", "t_10ms", "t_20ns", "t_30s", ] class Dummy: linalg = numpy.linalg class Foo: pass def add_day(arg0: datetime.datetime) -> datetime.datetime: ... foolist: list # value = [, ] foovar: Foo # value = list_with_none: list = [None, 2, {}] none = None t_10ms: datetime.timedelta # value = datetime.timedelta(microseconds=10000) t_20ns: datetime.timedelta # value = datetime.timedelta(0) t_30s: datetime.timedelta # value = datetime.timedelta(seconds=30) core.pyi000066400000000000000000000010211525537303700354520ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-wrap-with-annotated/demofrom __future__ import annotations from demo._bindings import ( aliases, classes, eigen, enum, flawed_bindings, functions, hidden_builtins, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) __all__: list[str] = [ "aliases", "classes", "eigen", "enum", "flawed_bindings", "functions", "hidden_builtins", "issues", "methods", "numpy", "properties", "stl", "stl_bind", "typing", "values", ] pure_python/000077500000000000000000000000001525537303700363615ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-wrap-with-annotated/demo__init__.pyi000066400000000000000000000003611525537303700406430ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations from . import classes, functions, functions_3_8_plus, functions_3_9_plus, values __all__: list[str] = [ "classes", "functions", "functions_3_8_plus", "functions_3_9_plus", "values", ] classes.pyi000066400000000000000000000003071525537303700405410ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["A", "B", "C", "X"] class A: """ A """ class B(A): """ B """ class C(B): """ C """ class X: pass functions.pyi000066400000000000000000000015561525537303700411230ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations import sys as sys import typing as typing from demo.pure_python.functions_3_8_plus import args_mix from demo.pure_python.functions_3_9_plus import generic_alias_annotation __all__: list[str] = [ "accept_frozenset", "args_mix", "builtin_function_as_default_arg", "function_as_default_arg", "generic_alias_annotation", "lambda_as_default_arg", "search", "static_method_as_default_arg", "sys", "typing", ] class _Dummy: @staticmethod def foo(): ... def accept_frozenset(arg: frozenset[int | float]) -> int | None: ... def builtin_function_as_default_arg(func: type(len) = len): ... def function_as_default_arg(func: type(search) = search): ... def lambda_as_default_arg(callback=...): ... def search(a: int, b: list[int]) -> int: ... def static_method_as_default_arg(callback=_Dummy.foo): ... functions_3_8_plus.pyi000066400000000000000000000007761525537303700426420ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations import typing as typing __all__: list[str] = [ "Expression", "Token", "args_mix", "nested_current_module_annotations", "typing", ] class Token: pass class Expression: pass def args_mix( a: int, b: float = 0.5, c: str = "", *args: int, x: int = 1, y=int, **kwargs: dict[int, str], ): ... def nested_current_module_annotations( tokens: list[Token], expr: Expression | None = None ) -> dict[str, Expression]: ... functions_3_9_plus.pyi000066400000000000000000000002601525537303700426270ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["generic_alias_annotation"] def generic_alias_annotation(a: list[tuple[int]], b: dict[int, str]) -> list[float]: ... values.pyi000066400000000000000000000001741525537303700404050ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.11/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["callables_dict"] callables_dict: dict = {"len": len, "int": int} pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/000077500000000000000000000000001525537303700226475ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11/000077500000000000000000000000001525537303700250435ustar00rootroot00000000000000numpy-array-wrap-with-annotated/000077500000000000000000000000001525537303700331435ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11demo/000077500000000000000000000000001525537303700340675ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11/numpy-array-wrap-with-annotated__init__.pyi000066400000000000000000000012021525537303700363440ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11/numpy-array-wrap-with-annotated/demofrom __future__ import annotations from demo._bindings import ( aliases, classes, eigen, enum, flawed_bindings, functions, hidden_builtins, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) from . import _bindings, core, pure_python __all__: list[str] = [ "aliases", "classes", "core", "eigen", "enum", "flawed_bindings", "functions", "hidden_builtins", "issues", "methods", "numpy", "properties", "pure_python", "stl", "stl_bind", "typing", "values", "version", ] version: str = "0.0.0" _bindings/000077500000000000000000000000001525537303700360235ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11/numpy-array-wrap-with-annotated/demo__init__.pyi000066400000000000000000000010041525537303700403000ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations from . import ( aliases, classes, eigen, enum, flawed_bindings, functions, hidden_builtins, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) __all__: list[str] = [ "aliases", "classes", "eigen", "enum", "flawed_bindings", "functions", "hidden_builtins", "issues", "methods", "numpy", "properties", "stl", "stl_bind", "typing", "values", ] aliases/000077500000000000000000000000001525537303700374445ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindings__init__.pyi000066400000000000000000000020761525537303700417330ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import typing import demo._bindings.enum import numpy from demo._bindings.aliases.foreign_method_arg import Bar2 as foreign_type_alias from demo._bindings.aliases.foreign_return import get_foo as foreign_class_alias from numpy import random from . import ( foreign_arg, foreign_attr, foreign_class_member, foreign_method_arg, foreign_method_return, foreign_return, missing_self_arg, ) __all__: list[str] = [ "Color", "Dummy", "foreign_arg", "foreign_attr", "foreign_class_alias", "foreign_class_member", "foreign_enum_default", "foreign_method_arg", "foreign_method_return", "foreign_return", "foreign_type_alias", "func", "local_func_alias", "local_type_alias", "missing_self_arg", "random", ] class Dummy: linalg = numpy.linalg class Color: pass def foreign_enum_default( color: typing.Any = demo._bindings.enum.ConsoleForegroundColor.Blue, ) -> None: ... def func(arg0: int) -> int: ... local_type_alias = Color local_func_alias = func foreign_arg.pyi000066400000000000000000000002371525537303700424530ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["set_foo"] def set_foo(arg0: demo._bindings.classes.Foo) -> int: ... foreign_attr.pyi000066400000000000000000000002631525537303700426530ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["value"] value: demo._bindings.classes.Foo # value = foreign_class_member.pyi000066400000000000000000000003571525537303700443410ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import typing import demo._bindings.classes __all__: list[str] = ["Bar1"] class Bar1: foo: typing.ClassVar[ demo._bindings.classes.Foo ] # value = foreign_method_arg.pyi000066400000000000000000000002621525537303700440110ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar2"] class Bar2: def set_foo(self, arg0: demo._bindings.classes.Foo) -> int: ... foreign_method_return.pyi000066400000000000000000000002651525537303700445620ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar3"] class Bar3: @staticmethod def get_foo() -> demo._bindings.classes.Foo: ... foreign_return.pyi000066400000000000000000000002261525537303700432170ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["get_foo"] def get_foo() -> demo._bindings.classes.Foo: ... missing_self_arg.pyi000066400000000000000000000002541525537303700435030ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar4"] class Bar4: def set_foo(self: demo._bindings.classes.Foo) -> int: ... classes.pyi000066400000000000000000000036571525537303700402160ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "CppException", "Derived", "Foo", "MyBase", "Outer", "ParIter", "ParIterBase", "ParticleContainer", ] class Outer: class Inner: class NestedEnum: """ Members: ONE TWO """ ONE: typing.ClassVar[Outer.Inner.NestedEnum] # value = TWO: typing.ClassVar[Outer.Inner.NestedEnum] # value = __members__: typing.ClassVar[ dict[str, Outer.Inner.NestedEnum] ] # value = {'ONE': , 'TWO': } def __eq__(self, other: typing.Any) -> bool: ... def __getstate__(self) -> int: ... def __hash__(self) -> int: ... def __index__(self) -> int: ... def __init__(self, value: int) -> None: ... def __int__(self) -> int: ... def __ne__(self, other: typing.Any) -> bool: ... def __repr__(self) -> str: ... def __setstate__(self, state: int) -> None: ... def __str__(self) -> str: ... @property def name(self) -> str: ... @property def value(self) -> int: ... value: Outer.Inner.NestedEnum inner: Outer.Inner class MyBase: class Inner: pass name: str class Derived(MyBase): count: int class Foo: class FooChild: def __init__(self) -> None: ... def g(self) -> None: ... def __init__(self) -> None: ... def f(self) -> None: ... class ParIterBase: level: int class ParIter(ParIterBase): def __init__(self, particle_container: ParticleContainer, level: int) -> None: ... class ParticleContainer: name: str Iterator = ParIter def process(self, arg0: ParIter) -> None: ... class CppException(Exception): pass eigen.pyi000066400000000000000000000060031525537303700376340ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing import numpy import scipy.sparse import pybind11_stubgen.typing_ext __all__: list[str] = [ "accept_matrix_int", "accept_vector_float64", "dense_matrix_c", "dense_matrix_r", "fixed_mutator_a", "fixed_mutator_c", "fixed_mutator_r", "four_col_matrix_r", "four_row_matrix_r", "get_matrix_int", "get_vector_float64", "sparse_matrix_c", "sparse_matrix_r", ] def accept_matrix_int( arg0: typing.Annotated[ numpy.ndarray, numpy.int32, pybind11_stubgen.typing_ext.FixedSize(3, 3) ], ) -> None: ... def accept_vector_float64( arg0: typing.Annotated[ numpy.ndarray, numpy.float64, pybind11_stubgen.typing_ext.FixedSize(3, 1) ], ) -> None: ... def dense_matrix_c( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", "n") ], ) -> typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", "n") ]: ... def dense_matrix_r( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", "n") ], ) -> typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", "n") ]: ... def fixed_mutator_a( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.FixedSize(5, 6), numpy.ndarray.flags.writeable, ], ) -> None: ... def fixed_mutator_c( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.FixedSize(5, 6), numpy.ndarray.flags.writeable, numpy.ndarray.flags.f_contiguous, ], ) -> None: ... def fixed_mutator_r( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.FixedSize(5, 6), numpy.ndarray.flags.writeable, numpy.ndarray.flags.c_contiguous, ], ) -> None: ... def four_col_matrix_r( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", 4) ], ) -> typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", 4) ]: ... def four_row_matrix_r( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize(4, "n") ], ) -> typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize(4, "n") ]: ... def get_matrix_int() -> typing.Annotated[ numpy.ndarray, numpy.int32, pybind11_stubgen.typing_ext.FixedSize(3, 3) ]: ... def get_vector_float64() -> typing.Annotated[ numpy.ndarray, numpy.float64, pybind11_stubgen.typing_ext.FixedSize(3, 1) ]: ... def sparse_matrix_c( arg0: typing.Annotated[scipy.sparse.csc_matrix, numpy.float32], ) -> typing.Annotated[scipy.sparse.csc_matrix, numpy.float32]: ... def sparse_matrix_r( arg0: typing.Annotated[scipy.sparse.csr_matrix, numpy.float32], ) -> typing.Annotated[scipy.sparse.csr_matrix, numpy.float32]: ... enum.pyi000066400000000000000000000042501525537303700375130ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "Blue", "ConsoleForegroundColor", "Green", "Magenta", "None_", "Yellow", "accept_defaulted_enum", ] class ConsoleForegroundColor: """ Members: Green Yellow Blue Magenta None_ """ Blue: typing.ClassVar[ ConsoleForegroundColor ] # value = Green: typing.ClassVar[ ConsoleForegroundColor ] # value = Magenta: typing.ClassVar[ ConsoleForegroundColor ] # value = None_: typing.ClassVar[ ConsoleForegroundColor ] # value = Yellow: typing.ClassVar[ ConsoleForegroundColor ] # value = __members__: typing.ClassVar[ dict[str, ConsoleForegroundColor] ] # value = {'Green': , 'Yellow': , 'Blue': , 'Magenta': , 'None_': } def __eq__(self, other: typing.Any) -> bool: ... def __getstate__(self) -> int: ... def __hash__(self) -> int: ... def __index__(self) -> int: ... def __init__(self, value: int) -> None: ... def __int__(self) -> int: ... def __ne__(self, other: typing.Any) -> bool: ... def __repr__(self) -> str: ... def __setstate__(self, state: int) -> None: ... def __str__(self) -> str: ... @property def name(self) -> str: ... @property def value(self) -> int: ... def accept_defaulted_enum( color: ConsoleForegroundColor = ConsoleForegroundColor.None_, ) -> None: ... Blue: ConsoleForegroundColor # value = Green: ConsoleForegroundColor # value = Magenta: ConsoleForegroundColor # value = None_: ConsoleForegroundColor # value = Yellow: ConsoleForegroundColor # value = flawed_bindings.pyi000066400000000000000000000010521525537303700416630ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations __all__: list[str] = [ "Enum", "Unbound", "accept_unbound_enum", "accept_unbound_enum_defaulted", "accept_unbound_type", "accept_unbound_type_defaulted", "get_unbound_type", ] class Unbound: pass class Enum: pass def accept_unbound_enum(arg0: ...) -> int: ... def accept_unbound_enum_defaulted(x: Enum = ...) -> int: ... def accept_unbound_type(arg0: tuple[..., int]) -> int: ... def accept_unbound_type_defaulted(x: Unbound = ...) -> int: ... def get_unbound_type() -> ...: ... functions.pyi000066400000000000000000000042311525537303700405560ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "Foo", "accept_callable", "accept_frozenset", "accept_py_handle", "accept_py_object", "accept_set", "add", "default_custom_arg", "default_int_arg", "default_list_arg", "default_optional_arg", "func_w_anon_args", "func_w_named_pos_args", "generic", "mul", "nested_types", "pass_callback", "passthrough1", "passthrough2", "passthrough3", "passthrough_backwards", "pos_kw_only_mix", "pos_kw_only_variadic_mix", ] class Foo: def __init__(self, arg0: int) -> None: ... def accept_callable(arg0: typing.Callable) -> typing.Any: ... def accept_frozenset(arg0: frozenset) -> None: ... def accept_py_handle(arg0: typing.Any) -> str: ... def accept_py_object(arg0: typing.Any) -> str: ... def accept_set(arg0: set) -> None: ... def add(arg0: int, arg1: int) -> int: ... def default_custom_arg(foo: Foo = Foo(5)) -> None: ... def default_int_arg(n: int = 5) -> None: ... def default_list_arg(l: list = [1, 2, 6, 18]) -> None: ... def default_optional_arg(n: int | None = None) -> None: ... def func_w_anon_args(arg0: int, arg1: int, arg2: int) -> None: ... def func_w_named_pos_args(x: int, y: int, z: int) -> None: ... def generic(*args, **kwargs) -> None: ... @typing.overload def mul(x: int, y: int) -> int: """ Multiply x and y (int) """ @typing.overload def mul(p: float, q: float) -> float: """ Multiply p and q (double) """ def nested_types(arg0: list[Foo] | Foo) -> list[Foo] | Foo: ... def pass_callback(arg0: typing.Callable[[Foo], Foo]) -> Foo: ... def passthrough1[T](obj: T) -> T: ... @typing.overload def passthrough2() -> None: ... @typing.overload def passthrough2[T](obj: T) -> T: ... @typing.overload def passthrough3() -> tuple[None, None]: ... @typing.overload def passthrough3[T](obj: T) -> tuple[T, None]: ... @typing.overload def passthrough3[T1, T2](obj1: T1, obj2: T2) -> tuple[T1, T2]: ... def passthrough_backwards[T](obj: T) -> T: ... def pos_kw_only_mix(i: int, /, j: int, *, k: int) -> tuple: ... def pos_kw_only_variadic_mix(i: int, /, j: int, *args, k: int, **kwargs) -> tuple: ... hidden_builtins.pyi000066400000000000000000000002571525537303700417160ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import types __all__: list[str] = ["mapping_proxy", "none"] mapping_proxy: types.MappingProxyType # value = mappingproxy({}) none = None issues.pyi000066400000000000000000000021111525537303700400540ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "backslashes_should_be_escaped", "issue_51_catastrophic_regex", "issue_73_utf8_doc_chars", "issue_274_docstring_leading_newline", ] def backslashes_should_be_escaped() -> None: """ \\brief A brief description of this function. A detailed description of this function. Here's some reStructuredText: :math:`x = [x, y, \\theta]^T` """ def issue_274_docstring_leading_newline() -> None: """ This is a docstring """ def issue_51_catastrophic_regex(arg0: int, arg1: int) -> None: """ Use-case: issue_51(os.get_handle_inheritable, os.set_handle_inheritable) """ def issue_73_utf8_doc_chars() -> None: """ Construct a Ramsete unicycle controller. Tuning parameter (b > 0 rad²/m²) for which larger values make convergence more aggressive like a proportional term. Tuning parameter (0 rad⁻¹ < zeta < 1 rad⁻¹) for which larger values provide more damping in response. """ _cleanup: typing.Any # value = methods.pyi000066400000000000000000000003041525537303700402060ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations __all__: list[str] = ["Dummy"] class Dummy: @staticmethod def static_method(arg0: int) -> int: ... def regular_method(self, arg0: int) -> int: ... numpy.pyi000066400000000000000000000011451525537303700377170ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing import numpy __all__: list[str] = [ "accept_ndarray_float64", "accept_ndarray_int", "get_ndarray_float64", "get_ndarray_int", "return_dtype", ] def accept_ndarray_float64( arg0: typing.Annotated[numpy.ndarray, numpy.float64], ) -> None: ... def accept_ndarray_int(arg0: typing.Annotated[numpy.ndarray, numpy.int32]) -> None: ... def get_ndarray_float64() -> typing.Annotated[numpy.ndarray, numpy.float64]: ... def get_ndarray_int() -> typing.Annotated[numpy.ndarray, numpy.int32]: ... def return_dtype() -> numpy.dtype[typing.Any]: ... properties.pyi000066400000000000000000000050711525537303700407450ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "WithGetterSetterDoc", "WithPropAndGetterSetterDoc", "WithPropDoc", "WithoutDoc", ] class WithoutDoc: """ No user docstring provided """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 def_property: int def_readwrite: int @property def def_property_readonly(self) -> int: ... @property def def_readonly(self) -> int: ... class WithPropDoc: """ User docstring provided only to `def_` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 """ prop doc token """ def_property_static: typing.ClassVar[int] = 0 """ prop doc token """ @property def def_property(self) -> int: """ prop doc token """ @def_property.setter def def_property(self, arg1: int) -> None: ... @property def def_property_readonly(self) -> int: """ prop doc token """ @property def def_readonly(self) -> int: """ prop doc token """ @property def def_readwrite(self) -> int: """ prop doc token """ @def_readwrite.setter def def_readwrite(self, arg0: int) -> None: ... class WithGetterSetterDoc: """ User docstring provided via pybind11::cpp_function(..., doc) to getters/setters, but NOT to `def_*(..., doc)` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 """ getter doc token """ def_property_static: typing.ClassVar[int] = 0 """ getter doc token """ @property def def_property(self) -> int: """ getter doc token """ @def_property.setter def def_property(self, arg1: int) -> None: """ setter doc token """ @property def def_property_readonly(self) -> int: """ getter doc token """ class WithPropAndGetterSetterDoc: """ User docstring provided via pybind11::cpp_function(..., doc) to getters/setters and to `def_*(, doc)` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 """ prop doc token """ def_property_static: typing.ClassVar[int] = 0 """ prop doc token """ @property def def_property(self) -> int: """ prop doc token """ @def_property.setter def def_property(self, arg1: int) -> None: ... @property def def_property_readonly(self) -> int: """ prop doc token """ stl.pyi000066400000000000000000000011061525537303700373460ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing import pybind11_stubgen.typing_ext __all__: list[str] = [ "std_array", "std_map", "std_optional", "std_variant", "std_vector", ] def std_array( arg0: typing.Annotated[list[int], pybind11_stubgen.typing_ext.FixedSize(3)], ) -> typing.Annotated[list[int], pybind11_stubgen.typing_ext.FixedSize(3)]: ... def std_map() -> dict[int, complex]: ... def std_optional(arg0: int | None) -> None: ... def std_variant(arg0: int | float | tuple[int, int]) -> None: ... def std_vector() -> list[tuple[int, float]]: ... stl_bind.pyi000066400000000000000000000075531525537303700403560ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "MapStringComplex", "VectorPairStringDouble", "get_complex_map", "get_vector_of_pairs", ] class VectorPairStringDouble: __hash__: typing.ClassVar[None] = None def __bool__(self) -> bool: """ Check whether the list is nonempty """ def __contains__(self, x: tuple[str, float]) -> bool: """ Return true the container contains ``x`` """ @typing.overload def __delitem__(self, arg0: int) -> None: """ Delete the list elements at index ``i`` """ @typing.overload def __delitem__(self, arg0: slice) -> None: """ Delete list elements using a slice object """ def __eq__(self, arg0: VectorPairStringDouble) -> bool: ... @typing.overload def __getitem__(self, s: slice) -> VectorPairStringDouble: """ Retrieve list elements using a slice object """ @typing.overload def __getitem__(self, arg0: int) -> tuple[str, float]: ... @typing.overload def __init__(self) -> None: ... @typing.overload def __init__(self, arg0: VectorPairStringDouble) -> None: """ Copy constructor """ @typing.overload def __init__(self, arg0: typing.Iterable) -> None: ... def __iter__(self) -> typing.Iterator: ... def __len__(self) -> int: ... def __ne__(self, arg0: VectorPairStringDouble) -> bool: ... @typing.overload def __setitem__(self, arg0: int, arg1: tuple[str, float]) -> None: ... @typing.overload def __setitem__(self, arg0: slice, arg1: VectorPairStringDouble) -> None: """ Assign list elements using a slice object """ def append(self, x: tuple[str, float]) -> None: """ Add an item to the end of the list """ def clear(self) -> None: """ Clear the contents """ def count(self, x: tuple[str, float]) -> int: """ Return the number of times ``x`` appears in the list """ @typing.overload def extend(self, L: VectorPairStringDouble) -> None: """ Extend the list by appending all the items in the given list """ @typing.overload def extend(self, L: typing.Iterable) -> None: """ Extend the list by appending all the items in the given list """ def insert(self, i: int, x: tuple[str, float]) -> None: """ Insert an item at a given position. """ @typing.overload def pop(self) -> tuple[str, float]: """ Remove and return the last item """ @typing.overload def pop(self, i: int) -> tuple[str, float]: """ Remove and return the item at index ``i`` """ def remove(self, x: tuple[str, float]) -> None: """ Remove the first item from the list whose value is x. It is an error if there is no such item. """ class MapStringComplex: def __bool__(self) -> bool: """ Check whether the map is nonempty """ @typing.overload def __contains__(self, arg0: str) -> bool: ... @typing.overload def __contains__(self, arg0: typing.Any) -> bool: ... def __delitem__(self, arg0: str) -> None: ... def __getitem__(self, arg0: str) -> complex: ... def __init__(self) -> None: ... def __iter__(self) -> typing.Iterator: ... def __len__(self) -> int: ... def __repr__(self) -> str: """ Return the canonical string representation of this map. """ def __setitem__(self, arg0: str, arg1: complex) -> None: ... def items(self) -> typing.ItemsView[str, complex]: ... def keys(self) -> typing.KeysView[str]: ... def values(self) -> typing.ValuesView[complex]: ... def get_complex_map() -> MapStringComplex: ... def get_vector_of_pairs() -> VectorPairStringDouble: ... typing.pyi000066400000000000000000000004221525537303700400560ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing import typing_extensions __all__: list[str] = ["get_buffer", "get_sequence"] def get_buffer(arg0: typing_extensions.Buffer) -> typing_extensions.Buffer: ... def get_sequence(arg0: typing.Sequence) -> typing.Sequence: ... values.pyi000066400000000000000000000014521525537303700400470ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import datetime import numpy from numpy import random __all__: list[str] = [ "Dummy", "Foo", "add_day", "foolist", "foovar", "list_with_none", "none", "random", "t_10ms", "t_20ns", "t_30s", ] class Dummy: linalg = numpy.linalg class Foo: pass def add_day(arg0: datetime.datetime) -> datetime.datetime: ... foolist: list # value = [, ] foovar: Foo # value = list_with_none: list = [None, 2, {}] none = None t_10ms: datetime.timedelta # value = datetime.timedelta(microseconds=10000) t_20ns: datetime.timedelta # value = datetime.timedelta(0) t_30s: datetime.timedelta # value = datetime.timedelta(seconds=30) core.pyi000066400000000000000000000010211525537303700355340ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11/numpy-array-wrap-with-annotated/demofrom __future__ import annotations from demo._bindings import ( aliases, classes, eigen, enum, flawed_bindings, functions, hidden_builtins, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) __all__: list[str] = [ "aliases", "classes", "eigen", "enum", "flawed_bindings", "functions", "hidden_builtins", "issues", "methods", "numpy", "properties", "stl", "stl_bind", "typing", "values", ] pure_python/000077500000000000000000000000001525537303700364435ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11/numpy-array-wrap-with-annotated/demo__init__.pyi000066400000000000000000000003611525537303700407250ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations from . import classes, functions, functions_3_8_plus, functions_3_9_plus, values __all__: list[str] = [ "classes", "functions", "functions_3_8_plus", "functions_3_9_plus", "values", ] classes.pyi000066400000000000000000000003071525537303700406230ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["A", "B", "C", "X"] class A: """ A """ class B(A): """ B """ class C(B): """ C """ class X: pass functions.pyi000066400000000000000000000015561525537303700412050ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations import sys as sys import typing as typing from demo.pure_python.functions_3_8_plus import args_mix from demo.pure_python.functions_3_9_plus import generic_alias_annotation __all__: list[str] = [ "accept_frozenset", "args_mix", "builtin_function_as_default_arg", "function_as_default_arg", "generic_alias_annotation", "lambda_as_default_arg", "search", "static_method_as_default_arg", "sys", "typing", ] class _Dummy: @staticmethod def foo(): ... def accept_frozenset(arg: frozenset[int | float]) -> int | None: ... def builtin_function_as_default_arg(func: type(len) = len): ... def function_as_default_arg(func: type(search) = search): ... def lambda_as_default_arg(callback=...): ... def search(a: int, b: list[int]) -> int: ... def static_method_as_default_arg(callback=_Dummy.foo): ... functions_3_8_plus.pyi000066400000000000000000000007761525537303700427240ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations import typing as typing __all__: list[str] = [ "Expression", "Token", "args_mix", "nested_current_module_annotations", "typing", ] class Token: pass class Expression: pass def args_mix( a: int, b: float = 0.5, c: str = "", *args: int, x: int = 1, y=int, **kwargs: dict[int, str], ): ... def nested_current_module_annotations( tokens: list[Token], expr: Expression | None = None ) -> dict[str, Expression]: ... functions_3_9_plus.pyi000066400000000000000000000002601525537303700427110ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["generic_alias_annotation"] def generic_alias_annotation(a: list[tuple[int]], b: dict[int, str]) -> list[float]: ... values.pyi000066400000000000000000000001741525537303700404670ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.11/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["callables_dict"] callables_dict: dict = {"len": len, "int": int} pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12/000077500000000000000000000000001525537303700250445ustar00rootroot00000000000000numpy-array-wrap-with-annotated/000077500000000000000000000000001525537303700331445ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12demo/000077500000000000000000000000001525537303700340705ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12/numpy-array-wrap-with-annotated__init__.pyi000066400000000000000000000012021525537303700363450ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12/numpy-array-wrap-with-annotated/demofrom __future__ import annotations from demo._bindings import ( aliases, classes, eigen, enum, flawed_bindings, functions, hidden_builtins, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) from . import _bindings, core, pure_python __all__: list[str] = [ "aliases", "classes", "core", "eigen", "enum", "flawed_bindings", "functions", "hidden_builtins", "issues", "methods", "numpy", "properties", "pure_python", "stl", "stl_bind", "typing", "values", "version", ] version: str = "0.0.0" _bindings/000077500000000000000000000000001525537303700360245ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12/numpy-array-wrap-with-annotated/demo__init__.pyi000066400000000000000000000010041525537303700403010ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations from . import ( aliases, classes, eigen, enum, flawed_bindings, functions, hidden_builtins, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) __all__: list[str] = [ "aliases", "classes", "eigen", "enum", "flawed_bindings", "functions", "hidden_builtins", "issues", "methods", "numpy", "properties", "stl", "stl_bind", "typing", "values", ] aliases/000077500000000000000000000000001525537303700374455ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindings__init__.pyi000066400000000000000000000020761525537303700417340ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import typing import demo._bindings.enum import numpy from demo._bindings.aliases.foreign_method_arg import Bar2 as foreign_type_alias from demo._bindings.aliases.foreign_return import get_foo as foreign_class_alias from numpy import random from . import ( foreign_arg, foreign_attr, foreign_class_member, foreign_method_arg, foreign_method_return, foreign_return, missing_self_arg, ) __all__: list[str] = [ "Color", "Dummy", "foreign_arg", "foreign_attr", "foreign_class_alias", "foreign_class_member", "foreign_enum_default", "foreign_method_arg", "foreign_method_return", "foreign_return", "foreign_type_alias", "func", "local_func_alias", "local_type_alias", "missing_self_arg", "random", ] class Dummy: linalg = numpy.linalg class Color: pass def foreign_enum_default( color: typing.Any = demo._bindings.enum.ConsoleForegroundColor.Blue, ) -> None: ... def func(arg0: int) -> int: ... local_type_alias = Color local_func_alias = func foreign_arg.pyi000066400000000000000000000002371525537303700424540ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["set_foo"] def set_foo(arg0: demo._bindings.classes.Foo) -> int: ... foreign_attr.pyi000066400000000000000000000002631525537303700426540ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["value"] value: demo._bindings.classes.Foo # value = foreign_class_member.pyi000066400000000000000000000003571525537303700443420ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import typing import demo._bindings.classes __all__: list[str] = ["Bar1"] class Bar1: foo: typing.ClassVar[ demo._bindings.classes.Foo ] # value = foreign_method_arg.pyi000066400000000000000000000002621525537303700440120ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar2"] class Bar2: def set_foo(self, arg0: demo._bindings.classes.Foo) -> int: ... foreign_method_return.pyi000066400000000000000000000002651525537303700445630ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar3"] class Bar3: @staticmethod def get_foo() -> demo._bindings.classes.Foo: ... foreign_return.pyi000066400000000000000000000002261525537303700432200ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["get_foo"] def get_foo() -> demo._bindings.classes.Foo: ... missing_self_arg.pyi000066400000000000000000000002541525537303700435040ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar4"] class Bar4: def set_foo(self: demo._bindings.classes.Foo) -> int: ... classes.pyi000066400000000000000000000036571525537303700402170ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "CppException", "Derived", "Foo", "MyBase", "Outer", "ParIter", "ParIterBase", "ParticleContainer", ] class Outer: class Inner: class NestedEnum: """ Members: ONE TWO """ ONE: typing.ClassVar[Outer.Inner.NestedEnum] # value = TWO: typing.ClassVar[Outer.Inner.NestedEnum] # value = __members__: typing.ClassVar[ dict[str, Outer.Inner.NestedEnum] ] # value = {'ONE': , 'TWO': } def __eq__(self, other: typing.Any) -> bool: ... def __getstate__(self) -> int: ... def __hash__(self) -> int: ... def __index__(self) -> int: ... def __init__(self, value: int) -> None: ... def __int__(self) -> int: ... def __ne__(self, other: typing.Any) -> bool: ... def __repr__(self) -> str: ... def __setstate__(self, state: int) -> None: ... def __str__(self) -> str: ... @property def name(self) -> str: ... @property def value(self) -> int: ... value: Outer.Inner.NestedEnum inner: Outer.Inner class MyBase: class Inner: pass name: str class Derived(MyBase): count: int class Foo: class FooChild: def __init__(self) -> None: ... def g(self) -> None: ... def __init__(self) -> None: ... def f(self) -> None: ... class ParIterBase: level: int class ParIter(ParIterBase): def __init__(self, particle_container: ParticleContainer, level: int) -> None: ... class ParticleContainer: name: str Iterator = ParIter def process(self, arg0: ParIter) -> None: ... class CppException(Exception): pass eigen.pyi000066400000000000000000000060031525537303700376350ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing import numpy import scipy.sparse import pybind11_stubgen.typing_ext __all__: list[str] = [ "accept_matrix_int", "accept_vector_float64", "dense_matrix_c", "dense_matrix_r", "fixed_mutator_a", "fixed_mutator_c", "fixed_mutator_r", "four_col_matrix_r", "four_row_matrix_r", "get_matrix_int", "get_vector_float64", "sparse_matrix_c", "sparse_matrix_r", ] def accept_matrix_int( arg0: typing.Annotated[ numpy.ndarray, numpy.int32, pybind11_stubgen.typing_ext.FixedSize(3, 3) ], ) -> None: ... def accept_vector_float64( arg0: typing.Annotated[ numpy.ndarray, numpy.float64, pybind11_stubgen.typing_ext.FixedSize(3, 1) ], ) -> None: ... def dense_matrix_c( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", "n") ], ) -> typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", "n") ]: ... def dense_matrix_r( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", "n") ], ) -> typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", "n") ]: ... def fixed_mutator_a( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.FixedSize(5, 6), numpy.ndarray.flags.writeable, ], ) -> None: ... def fixed_mutator_c( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.FixedSize(5, 6), numpy.ndarray.flags.writeable, numpy.ndarray.flags.f_contiguous, ], ) -> None: ... def fixed_mutator_r( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.FixedSize(5, 6), numpy.ndarray.flags.writeable, numpy.ndarray.flags.c_contiguous, ], ) -> None: ... def four_col_matrix_r( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", 4) ], ) -> typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", 4) ]: ... def four_row_matrix_r( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize(4, "n") ], ) -> typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize(4, "n") ]: ... def get_matrix_int() -> typing.Annotated[ numpy.ndarray, numpy.int32, pybind11_stubgen.typing_ext.FixedSize(3, 3) ]: ... def get_vector_float64() -> typing.Annotated[ numpy.ndarray, numpy.float64, pybind11_stubgen.typing_ext.FixedSize(3, 1) ]: ... def sparse_matrix_c( arg0: typing.Annotated[scipy.sparse.csc_matrix, numpy.float32], ) -> typing.Annotated[scipy.sparse.csc_matrix, numpy.float32]: ... def sparse_matrix_r( arg0: typing.Annotated[scipy.sparse.csr_matrix, numpy.float32], ) -> typing.Annotated[scipy.sparse.csr_matrix, numpy.float32]: ... enum.pyi000066400000000000000000000042501525537303700375140ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "Blue", "ConsoleForegroundColor", "Green", "Magenta", "None_", "Yellow", "accept_defaulted_enum", ] class ConsoleForegroundColor: """ Members: Green Yellow Blue Magenta None_ """ Blue: typing.ClassVar[ ConsoleForegroundColor ] # value = Green: typing.ClassVar[ ConsoleForegroundColor ] # value = Magenta: typing.ClassVar[ ConsoleForegroundColor ] # value = None_: typing.ClassVar[ ConsoleForegroundColor ] # value = Yellow: typing.ClassVar[ ConsoleForegroundColor ] # value = __members__: typing.ClassVar[ dict[str, ConsoleForegroundColor] ] # value = {'Green': , 'Yellow': , 'Blue': , 'Magenta': , 'None_': } def __eq__(self, other: typing.Any) -> bool: ... def __getstate__(self) -> int: ... def __hash__(self) -> int: ... def __index__(self) -> int: ... def __init__(self, value: int) -> None: ... def __int__(self) -> int: ... def __ne__(self, other: typing.Any) -> bool: ... def __repr__(self) -> str: ... def __setstate__(self, state: int) -> None: ... def __str__(self) -> str: ... @property def name(self) -> str: ... @property def value(self) -> int: ... def accept_defaulted_enum( color: ConsoleForegroundColor = ConsoleForegroundColor.None_, ) -> None: ... Blue: ConsoleForegroundColor # value = Green: ConsoleForegroundColor # value = Magenta: ConsoleForegroundColor # value = None_: ConsoleForegroundColor # value = Yellow: ConsoleForegroundColor # value = flawed_bindings.pyi000066400000000000000000000010521525537303700416640ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations __all__: list[str] = [ "Enum", "Unbound", "accept_unbound_enum", "accept_unbound_enum_defaulted", "accept_unbound_type", "accept_unbound_type_defaulted", "get_unbound_type", ] class Unbound: pass class Enum: pass def accept_unbound_enum(arg0: ...) -> int: ... def accept_unbound_enum_defaulted(x: Enum = ...) -> int: ... def accept_unbound_type(arg0: tuple[..., int]) -> int: ... def accept_unbound_type_defaulted(x: Unbound = ...) -> int: ... def get_unbound_type() -> ...: ... functions.pyi000066400000000000000000000044231525537303700405620ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "Foo", "accept_annotated_callable", "accept_callable", "accept_frozenset", "accept_py_handle", "accept_py_object", "accept_set", "add", "default_custom_arg", "default_int_arg", "default_list_arg", "default_optional_arg", "func_w_anon_args", "func_w_named_pos_args", "generic", "mul", "nested_types", "pass_callback", "passthrough1", "passthrough2", "passthrough3", "passthrough_backwards", "pos_kw_only_mix", "pos_kw_only_variadic_mix", ] class Foo: def __init__(self, arg0: int) -> None: ... def accept_annotated_callable(arg0: typing.Callable[[int, int], int]) -> typing.Any: ... def accept_callable(arg0: typing.Callable) -> typing.Any: ... def accept_frozenset(arg0: frozenset) -> None: ... def accept_py_handle(arg0: typing.Any) -> str: ... def accept_py_object(arg0: typing.Any) -> str: ... def accept_set(arg0: set) -> None: ... def add(arg0: int, arg1: int) -> int: ... def default_custom_arg(foo: Foo = Foo(5)) -> None: ... def default_int_arg(n: int = 5) -> None: ... def default_list_arg(l: list = [1, 2, 6, 18]) -> None: ... def default_optional_arg(n: int | None = None) -> None: ... def func_w_anon_args(arg0: int, arg1: int, arg2: int) -> None: ... def func_w_named_pos_args(x: int, y: int, z: int) -> None: ... def generic(*args, **kwargs) -> None: ... @typing.overload def mul(x: int, y: int) -> int: """ Multiply x and y (int) """ @typing.overload def mul(p: float, q: float) -> float: """ Multiply p and q (double) """ def nested_types(arg0: list[Foo] | Foo) -> list[Foo] | Foo: ... def pass_callback(arg0: typing.Callable[[Foo], Foo]) -> Foo: ... def passthrough1[T](obj: T) -> T: ... @typing.overload def passthrough2() -> None: ... @typing.overload def passthrough2[T](obj: T) -> T: ... @typing.overload def passthrough3() -> tuple[None, None]: ... @typing.overload def passthrough3[T](obj: T) -> tuple[T, None]: ... @typing.overload def passthrough3[T1, T2](obj1: T1, obj2: T2) -> tuple[T1, T2]: ... def passthrough_backwards[T](obj: T) -> T: ... def pos_kw_only_mix(i: int, /, j: int, *, k: int) -> tuple: ... def pos_kw_only_variadic_mix(i: int, /, j: int, *args, k: int, **kwargs) -> tuple: ... hidden_builtins.pyi000066400000000000000000000002571525537303700417170ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import types __all__: list[str] = ["mapping_proxy", "none"] mapping_proxy: types.MappingProxyType # value = mappingproxy({}) none = None issues.pyi000066400000000000000000000021111525537303700400550ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "backslashes_should_be_escaped", "issue_51_catastrophic_regex", "issue_73_utf8_doc_chars", "issue_274_docstring_leading_newline", ] def backslashes_should_be_escaped() -> None: """ \\brief A brief description of this function. A detailed description of this function. Here's some reStructuredText: :math:`x = [x, y, \\theta]^T` """ def issue_274_docstring_leading_newline() -> None: """ This is a docstring """ def issue_51_catastrophic_regex(arg0: int, arg1: int) -> None: """ Use-case: issue_51(os.get_handle_inheritable, os.set_handle_inheritable) """ def issue_73_utf8_doc_chars() -> None: """ Construct a Ramsete unicycle controller. Tuning parameter (b > 0 rad²/m²) for which larger values make convergence more aggressive like a proportional term. Tuning parameter (0 rad⁻¹ < zeta < 1 rad⁻¹) for which larger values provide more damping in response. """ _cleanup: typing.Any # value = methods.pyi000066400000000000000000000003041525537303700402070ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations __all__: list[str] = ["Dummy"] class Dummy: @staticmethod def static_method(arg0: int) -> int: ... def regular_method(self, arg0: int) -> int: ... numpy.pyi000066400000000000000000000011451525537303700377200ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing import numpy __all__: list[str] = [ "accept_ndarray_float64", "accept_ndarray_int", "get_ndarray_float64", "get_ndarray_int", "return_dtype", ] def accept_ndarray_float64( arg0: typing.Annotated[numpy.ndarray, numpy.float64], ) -> None: ... def accept_ndarray_int(arg0: typing.Annotated[numpy.ndarray, numpy.int32]) -> None: ... def get_ndarray_float64() -> typing.Annotated[numpy.ndarray, numpy.float64]: ... def get_ndarray_int() -> typing.Annotated[numpy.ndarray, numpy.int32]: ... def return_dtype() -> numpy.dtype[typing.Any]: ... properties.pyi000066400000000000000000000050711525537303700407460ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "WithGetterSetterDoc", "WithPropAndGetterSetterDoc", "WithPropDoc", "WithoutDoc", ] class WithoutDoc: """ No user docstring provided """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 def_property: int def_readwrite: int @property def def_property_readonly(self) -> int: ... @property def def_readonly(self) -> int: ... class WithPropDoc: """ User docstring provided only to `def_` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 """ prop doc token """ def_property_static: typing.ClassVar[int] = 0 """ prop doc token """ @property def def_property(self) -> int: """ prop doc token """ @def_property.setter def def_property(self, arg1: int) -> None: ... @property def def_property_readonly(self) -> int: """ prop doc token """ @property def def_readonly(self) -> int: """ prop doc token """ @property def def_readwrite(self) -> int: """ prop doc token """ @def_readwrite.setter def def_readwrite(self, arg0: int) -> None: ... class WithGetterSetterDoc: """ User docstring provided via pybind11::cpp_function(..., doc) to getters/setters, but NOT to `def_*(..., doc)` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 """ getter doc token """ def_property_static: typing.ClassVar[int] = 0 """ getter doc token """ @property def def_property(self) -> int: """ getter doc token """ @def_property.setter def def_property(self, arg1: int) -> None: """ setter doc token """ @property def def_property_readonly(self) -> int: """ getter doc token """ class WithPropAndGetterSetterDoc: """ User docstring provided via pybind11::cpp_function(..., doc) to getters/setters and to `def_*(, doc)` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 """ prop doc token """ def_property_static: typing.ClassVar[int] = 0 """ prop doc token """ @property def def_property(self) -> int: """ prop doc token """ @def_property.setter def def_property(self, arg1: int) -> None: ... @property def def_property_readonly(self) -> int: """ prop doc token """ stl.pyi000066400000000000000000000011061525537303700373470ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing import pybind11_stubgen.typing_ext __all__: list[str] = [ "std_array", "std_map", "std_optional", "std_variant", "std_vector", ] def std_array( arg0: typing.Annotated[list[int], pybind11_stubgen.typing_ext.FixedSize(3)], ) -> typing.Annotated[list[int], pybind11_stubgen.typing_ext.FixedSize(3)]: ... def std_map() -> dict[int, complex]: ... def std_optional(arg0: int | None) -> None: ... def std_variant(arg0: int | float | tuple[int, int]) -> None: ... def std_vector() -> list[tuple[int, float]]: ... stl_bind.pyi000066400000000000000000000075471525537303700403620ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "MapStringComplex", "VectorPairStringDouble", "get_complex_map", "get_vector_of_pairs", ] class VectorPairStringDouble: __hash__: typing.ClassVar[None] = None def __bool__(self) -> bool: """ Check whether the list is nonempty """ def __contains__(self, x: tuple[str, float]) -> bool: """ Return true the container contains ``x`` """ @typing.overload def __delitem__(self, arg0: int) -> None: """ Delete the list elements at index ``i`` """ @typing.overload def __delitem__(self, arg0: slice) -> None: """ Delete list elements using a slice object """ def __eq__(self, arg0: VectorPairStringDouble) -> bool: ... @typing.overload def __getitem__(self, s: slice) -> VectorPairStringDouble: """ Retrieve list elements using a slice object """ @typing.overload def __getitem__(self, arg0: int) -> tuple[str, float]: ... @typing.overload def __init__(self) -> None: ... @typing.overload def __init__(self, arg0: VectorPairStringDouble) -> None: """ Copy constructor """ @typing.overload def __init__(self, arg0: typing.Iterable) -> None: ... def __iter__(self) -> typing.Iterator[tuple[str, float]]: ... def __len__(self) -> int: ... def __ne__(self, arg0: VectorPairStringDouble) -> bool: ... @typing.overload def __setitem__(self, arg0: int, arg1: tuple[str, float]) -> None: ... @typing.overload def __setitem__(self, arg0: slice, arg1: VectorPairStringDouble) -> None: """ Assign list elements using a slice object """ def append(self, x: tuple[str, float]) -> None: """ Add an item to the end of the list """ def clear(self) -> None: """ Clear the contents """ def count(self, x: tuple[str, float]) -> int: """ Return the number of times ``x`` appears in the list """ @typing.overload def extend(self, L: VectorPairStringDouble) -> None: """ Extend the list by appending all the items in the given list """ @typing.overload def extend(self, L: typing.Iterable) -> None: """ Extend the list by appending all the items in the given list """ def insert(self, i: int, x: tuple[str, float]) -> None: """ Insert an item at a given position. """ @typing.overload def pop(self) -> tuple[str, float]: """ Remove and return the last item """ @typing.overload def pop(self, i: int) -> tuple[str, float]: """ Remove and return the item at index ``i`` """ def remove(self, x: tuple[str, float]) -> None: """ Remove the first item from the list whose value is x. It is an error if there is no such item. """ class MapStringComplex: def __bool__(self) -> bool: """ Check whether the map is nonempty """ @typing.overload def __contains__(self, arg0: str) -> bool: ... @typing.overload def __contains__(self, arg0: typing.Any) -> bool: ... def __delitem__(self, arg0: str) -> None: ... def __getitem__(self, arg0: str) -> complex: ... def __init__(self) -> None: ... def __iter__(self) -> typing.Iterator[str]: ... def __len__(self) -> int: ... def __repr__(self) -> str: """ Return the canonical string representation of this map. """ def __setitem__(self, arg0: str, arg1: complex) -> None: ... def items(self) -> typing.ItemsView: ... def keys(self) -> typing.KeysView: ... def values(self) -> typing.ValuesView: ... def get_complex_map() -> MapStringComplex: ... def get_vector_of_pairs() -> VectorPairStringDouble: ... typing.pyi000066400000000000000000000004221525537303700400570ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing import typing_extensions __all__: list[str] = ["get_buffer", "get_sequence"] def get_buffer(arg0: typing_extensions.Buffer) -> typing_extensions.Buffer: ... def get_sequence(arg0: typing.Sequence) -> typing.Sequence: ... values.pyi000066400000000000000000000014521525537303700400500ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import datetime import numpy from numpy import random __all__: list[str] = [ "Dummy", "Foo", "add_day", "foolist", "foovar", "list_with_none", "none", "random", "t_10ms", "t_20ns", "t_30s", ] class Dummy: linalg = numpy.linalg class Foo: pass def add_day(arg0: datetime.datetime) -> datetime.datetime: ... foolist: list # value = [, ] foovar: Foo # value = list_with_none: list = [None, 2, {}] none = None t_10ms: datetime.timedelta # value = datetime.timedelta(microseconds=10000) t_20ns: datetime.timedelta # value = datetime.timedelta(0) t_30s: datetime.timedelta # value = datetime.timedelta(seconds=30) core.pyi000066400000000000000000000010211525537303700355350ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12/numpy-array-wrap-with-annotated/demofrom __future__ import annotations from demo._bindings import ( aliases, classes, eigen, enum, flawed_bindings, functions, hidden_builtins, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) __all__: list[str] = [ "aliases", "classes", "eigen", "enum", "flawed_bindings", "functions", "hidden_builtins", "issues", "methods", "numpy", "properties", "stl", "stl_bind", "typing", "values", ] pure_python/000077500000000000000000000000001525537303700364445ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12/numpy-array-wrap-with-annotated/demo__init__.pyi000066400000000000000000000003611525537303700407260ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations from . import classes, functions, functions_3_8_plus, functions_3_9_plus, values __all__: list[str] = [ "classes", "functions", "functions_3_8_plus", "functions_3_9_plus", "values", ] classes.pyi000066400000000000000000000003071525537303700406240ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["A", "B", "C", "X"] class A: """ A """ class B(A): """ B """ class C(B): """ C """ class X: pass functions.pyi000066400000000000000000000015561525537303700412060ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations import sys as sys import typing as typing from demo.pure_python.functions_3_8_plus import args_mix from demo.pure_python.functions_3_9_plus import generic_alias_annotation __all__: list[str] = [ "accept_frozenset", "args_mix", "builtin_function_as_default_arg", "function_as_default_arg", "generic_alias_annotation", "lambda_as_default_arg", "search", "static_method_as_default_arg", "sys", "typing", ] class _Dummy: @staticmethod def foo(): ... def accept_frozenset(arg: frozenset[int | float]) -> int | None: ... def builtin_function_as_default_arg(func: type(len) = len): ... def function_as_default_arg(func: type(search) = search): ... def lambda_as_default_arg(callback=...): ... def search(a: int, b: list[int]) -> int: ... def static_method_as_default_arg(callback=_Dummy.foo): ... functions_3_8_plus.pyi000066400000000000000000000007761525537303700427250ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations import typing as typing __all__: list[str] = [ "Expression", "Token", "args_mix", "nested_current_module_annotations", "typing", ] class Token: pass class Expression: pass def args_mix( a: int, b: float = 0.5, c: str = "", *args: int, x: int = 1, y=int, **kwargs: dict[int, str], ): ... def nested_current_module_annotations( tokens: list[Token], expr: Expression | None = None ) -> dict[str, Expression]: ... functions_3_9_plus.pyi000066400000000000000000000002601525537303700427120ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["generic_alias_annotation"] def generic_alias_annotation(a: list[tuple[int]], b: dict[int, str]) -> list[float]: ... values.pyi000066400000000000000000000001741525537303700404700ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.12/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["callables_dict"] callables_dict: dict = {"len": len, "int": int} pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/000077500000000000000000000000001525537303700250455ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-use-type-var/000077500000000000000000000000001525537303700316705ustar00rootroot00000000000000demo/000077500000000000000000000000001525537303700325355ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-use-type-var__init__.pyi000066400000000000000000000012021525537303700350120ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-use-type-var/demofrom __future__ import annotations from demo._bindings import ( aliases, classes, eigen, enum, flawed_bindings, functions, hidden_builtins, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) from . import _bindings, core, pure_python __all__: list[str] = [ "aliases", "classes", "core", "eigen", "enum", "flawed_bindings", "functions", "hidden_builtins", "issues", "methods", "numpy", "properties", "pure_python", "stl", "stl_bind", "typing", "values", "version", ] version: str = "0.0.0" _bindings/000077500000000000000000000000001525537303700344715ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-use-type-var/demo__init__.pyi000066400000000000000000000010041525537303700367460ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations from . import ( aliases, classes, eigen, enum, flawed_bindings, functions, hidden_builtins, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) __all__: list[str] = [ "aliases", "classes", "eigen", "enum", "flawed_bindings", "functions", "hidden_builtins", "issues", "methods", "numpy", "properties", "stl", "stl_bind", "typing", "values", ] aliases/000077500000000000000000000000001525537303700361125ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-use-type-var/demo/_bindings__init__.pyi000066400000000000000000000020761525537303700404010ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-use-type-var/demo/_bindings/aliasesfrom __future__ import annotations import typing import demo._bindings.enum import numpy from demo._bindings.aliases.foreign_method_arg import Bar2 as foreign_type_alias from demo._bindings.aliases.foreign_return import get_foo as foreign_class_alias from numpy import random from . import ( foreign_arg, foreign_attr, foreign_class_member, foreign_method_arg, foreign_method_return, foreign_return, missing_self_arg, ) __all__: list[str] = [ "Color", "Dummy", "foreign_arg", "foreign_attr", "foreign_class_alias", "foreign_class_member", "foreign_enum_default", "foreign_method_arg", "foreign_method_return", "foreign_return", "foreign_type_alias", "func", "local_func_alias", "local_type_alias", "missing_self_arg", "random", ] class Dummy: linalg = numpy.linalg class Color: pass def foreign_enum_default( color: typing.Any = demo._bindings.enum.ConsoleForegroundColor.Blue, ) -> None: ... def func(arg0: int) -> int: ... local_type_alias = Color local_func_alias = func foreign_arg.pyi000066400000000000000000000002371525537303700411210ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-use-type-var/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["set_foo"] def set_foo(arg0: demo._bindings.classes.Foo) -> int: ... foreign_attr.pyi000066400000000000000000000002631525537303700413210ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-use-type-var/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["value"] value: demo._bindings.classes.Foo # value = foreign_class_member.pyi000066400000000000000000000003571525537303700430070ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-use-type-var/demo/_bindings/aliasesfrom __future__ import annotations import typing import demo._bindings.classes __all__: list[str] = ["Bar1"] class Bar1: foo: typing.ClassVar[ demo._bindings.classes.Foo ] # value = foreign_method_arg.pyi000066400000000000000000000002621525537303700424570ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-use-type-var/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar2"] class Bar2: def set_foo(self, arg0: demo._bindings.classes.Foo) -> int: ... foreign_method_return.pyi000066400000000000000000000002651525537303700432300ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-use-type-var/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar3"] class Bar3: @staticmethod def get_foo() -> demo._bindings.classes.Foo: ... foreign_return.pyi000066400000000000000000000002261525537303700416650ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-use-type-var/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["get_foo"] def get_foo() -> demo._bindings.classes.Foo: ... missing_self_arg.pyi000066400000000000000000000002541525537303700421510ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-use-type-var/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar4"] class Bar4: def set_foo(self: demo._bindings.classes.Foo) -> int: ... classes.pyi000066400000000000000000000036571525537303700366640ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "CppException", "Derived", "Foo", "MyBase", "Outer", "ParIter", "ParIterBase", "ParticleContainer", ] class Outer: class Inner: class NestedEnum: """ Members: ONE TWO """ ONE: typing.ClassVar[Outer.Inner.NestedEnum] # value = TWO: typing.ClassVar[Outer.Inner.NestedEnum] # value = __members__: typing.ClassVar[ dict[str, Outer.Inner.NestedEnum] ] # value = {'ONE': , 'TWO': } def __eq__(self, other: typing.Any) -> bool: ... def __getstate__(self) -> int: ... def __hash__(self) -> int: ... def __index__(self) -> int: ... def __init__(self, value: int) -> None: ... def __int__(self) -> int: ... def __ne__(self, other: typing.Any) -> bool: ... def __repr__(self) -> str: ... def __setstate__(self, state: int) -> None: ... def __str__(self) -> str: ... @property def name(self) -> str: ... @property def value(self) -> int: ... value: Outer.Inner.NestedEnum inner: Outer.Inner class MyBase: class Inner: pass name: str class Derived(MyBase): count: int class Foo: class FooChild: def __init__(self) -> None: ... def g(self) -> None: ... def __init__(self) -> None: ... def f(self) -> None: ... class ParIterBase: level: int class ParIter(ParIterBase): def __init__(self, particle_container: ParticleContainer, level: int) -> None: ... class ParticleContainer: name: str Iterator = ParIter def process(self, arg0: ParIter) -> None: ... class CppException(Exception): pass eigen.pyi000066400000000000000000000044241525537303700363070ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import typing import numpy import scipy.sparse __all__: list[str] = [ "accept_matrix_int", "accept_vector_float64", "dense_matrix_c", "dense_matrix_r", "fixed_mutator_a", "fixed_mutator_c", "fixed_mutator_r", "four_col_matrix_r", "four_row_matrix_r", "get_matrix_int", "get_vector_float64", "sparse_matrix_c", "sparse_matrix_r", ] M = typing.TypeVar("M", bound=int) N = typing.TypeVar("N", bound=int) def accept_matrix_int( arg0: numpy.ndarray[ tuple[typing.Literal[3], typing.Literal[3]], numpy.dtype[numpy.int32] ], ) -> None: ... def accept_vector_float64( arg0: numpy.ndarray[ tuple[typing.Literal[3], typing.Literal[1]], numpy.dtype[numpy.float64] ], ) -> None: ... def dense_matrix_c( arg0: numpy.ndarray[tuple[M, N], numpy.dtype[numpy.float32]], ) -> numpy.ndarray[tuple[M, N], numpy.dtype[numpy.float32]]: ... def dense_matrix_r( arg0: numpy.ndarray[tuple[M, N], numpy.dtype[numpy.float32]], ) -> numpy.ndarray[tuple[M, N], numpy.dtype[numpy.float32]]: ... def fixed_mutator_a( arg0: numpy.ndarray[ tuple[typing.Literal[5], typing.Literal[6]], numpy.dtype[numpy.float32] ], ) -> None: ... def fixed_mutator_c( arg0: numpy.ndarray[ tuple[typing.Literal[5], typing.Literal[6]], numpy.dtype[numpy.float32] ], ) -> None: ... def fixed_mutator_r( arg0: numpy.ndarray[ tuple[typing.Literal[5], typing.Literal[6]], numpy.dtype[numpy.float32] ], ) -> None: ... def four_col_matrix_r( arg0: numpy.ndarray[tuple[M, typing.Literal[4]], numpy.dtype[numpy.float32]], ) -> numpy.ndarray[tuple[M, typing.Literal[4]], numpy.dtype[numpy.float32]]: ... def four_row_matrix_r( arg0: numpy.ndarray[tuple[typing.Literal[4], N], numpy.dtype[numpy.float32]], ) -> numpy.ndarray[tuple[typing.Literal[4], N], numpy.dtype[numpy.float32]]: ... def get_matrix_int() -> numpy.ndarray[ tuple[typing.Literal[3], typing.Literal[3]], numpy.dtype[numpy.int32] ]: ... def get_vector_float64() -> numpy.ndarray[ tuple[typing.Literal[3], typing.Literal[1]], numpy.dtype[numpy.float64] ]: ... def sparse_matrix_c(arg0: scipy.sparse.csc_matrix) -> scipy.sparse.csc_matrix: ... def sparse_matrix_r(arg0: scipy.sparse.csr_matrix) -> scipy.sparse.csr_matrix: ... enum.pyi000066400000000000000000000042501525537303700361610ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "Blue", "ConsoleForegroundColor", "Green", "Magenta", "None_", "Yellow", "accept_defaulted_enum", ] class ConsoleForegroundColor: """ Members: Green Yellow Blue Magenta None_ """ Blue: typing.ClassVar[ ConsoleForegroundColor ] # value = Green: typing.ClassVar[ ConsoleForegroundColor ] # value = Magenta: typing.ClassVar[ ConsoleForegroundColor ] # value = None_: typing.ClassVar[ ConsoleForegroundColor ] # value = Yellow: typing.ClassVar[ ConsoleForegroundColor ] # value = __members__: typing.ClassVar[ dict[str, ConsoleForegroundColor] ] # value = {'Green': , 'Yellow': , 'Blue': , 'Magenta': , 'None_': } def __eq__(self, other: typing.Any) -> bool: ... def __getstate__(self) -> int: ... def __hash__(self) -> int: ... def __index__(self) -> int: ... def __init__(self, value: int) -> None: ... def __int__(self) -> int: ... def __ne__(self, other: typing.Any) -> bool: ... def __repr__(self) -> str: ... def __setstate__(self, state: int) -> None: ... def __str__(self) -> str: ... @property def name(self) -> str: ... @property def value(self) -> int: ... def accept_defaulted_enum( color: ConsoleForegroundColor = ConsoleForegroundColor.None_, ) -> None: ... Blue: ConsoleForegroundColor # value = Green: ConsoleForegroundColor # value = Magenta: ConsoleForegroundColor # value = None_: ConsoleForegroundColor # value = Yellow: ConsoleForegroundColor # value = flawed_bindings.pyi000066400000000000000000000010521525537303700403310ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations __all__: list[str] = [ "Enum", "Unbound", "accept_unbound_enum", "accept_unbound_enum_defaulted", "accept_unbound_type", "accept_unbound_type_defaulted", "get_unbound_type", ] class Unbound: pass class Enum: pass def accept_unbound_enum(arg0: ...) -> int: ... def accept_unbound_enum_defaulted(x: Enum = ...) -> int: ... def accept_unbound_type(arg0: tuple[..., int]) -> int: ... def accept_unbound_type_defaulted(x: Unbound = ...) -> int: ... def get_unbound_type() -> ...: ... functions.pyi000066400000000000000000000044231525537303700372270ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "Foo", "accept_annotated_callable", "accept_callable", "accept_frozenset", "accept_py_handle", "accept_py_object", "accept_set", "add", "default_custom_arg", "default_int_arg", "default_list_arg", "default_optional_arg", "func_w_anon_args", "func_w_named_pos_args", "generic", "mul", "nested_types", "pass_callback", "passthrough1", "passthrough2", "passthrough3", "passthrough_backwards", "pos_kw_only_mix", "pos_kw_only_variadic_mix", ] class Foo: def __init__(self, arg0: int) -> None: ... def accept_annotated_callable(arg0: typing.Callable[[int, int], int]) -> typing.Any: ... def accept_callable(arg0: typing.Callable) -> typing.Any: ... def accept_frozenset(arg0: frozenset) -> None: ... def accept_py_handle(arg0: typing.Any) -> str: ... def accept_py_object(arg0: typing.Any) -> str: ... def accept_set(arg0: set) -> None: ... def add(arg0: int, arg1: int) -> int: ... def default_custom_arg(foo: Foo = Foo(5)) -> None: ... def default_int_arg(n: int = 5) -> None: ... def default_list_arg(l: list = [1, 2, 6, 18]) -> None: ... def default_optional_arg(n: int | None = None) -> None: ... def func_w_anon_args(arg0: int, arg1: int, arg2: int) -> None: ... def func_w_named_pos_args(x: int, y: int, z: int) -> None: ... def generic(*args, **kwargs) -> None: ... @typing.overload def mul(x: int, y: int) -> int: """ Multiply x and y (int) """ @typing.overload def mul(p: float, q: float) -> float: """ Multiply p and q (double) """ def nested_types(arg0: list[Foo] | Foo) -> list[Foo] | Foo: ... def pass_callback(arg0: typing.Callable[[Foo], Foo]) -> Foo: ... def passthrough1[T](obj: T) -> T: ... @typing.overload def passthrough2() -> None: ... @typing.overload def passthrough2[T](obj: T) -> T: ... @typing.overload def passthrough3() -> tuple[None, None]: ... @typing.overload def passthrough3[T](obj: T) -> tuple[T, None]: ... @typing.overload def passthrough3[T1, T2](obj1: T1, obj2: T2) -> tuple[T1, T2]: ... def passthrough_backwards[T](obj: T) -> T: ... def pos_kw_only_mix(i: int, /, j: int, *, k: int) -> tuple: ... def pos_kw_only_variadic_mix(i: int, /, j: int, *args, k: int, **kwargs) -> tuple: ... hidden_builtins.pyi000066400000000000000000000002571525537303700403640ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import types __all__: list[str] = ["mapping_proxy", "none"] mapping_proxy: types.MappingProxyType # value = mappingproxy({}) none = None issues.pyi000066400000000000000000000021111525537303700365220ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "backslashes_should_be_escaped", "issue_51_catastrophic_regex", "issue_73_utf8_doc_chars", "issue_274_docstring_leading_newline", ] def backslashes_should_be_escaped() -> None: """ \\brief A brief description of this function. A detailed description of this function. Here's some reStructuredText: :math:`x = [x, y, \\theta]^T` """ def issue_274_docstring_leading_newline() -> None: """ This is a docstring """ def issue_51_catastrophic_regex(arg0: int, arg1: int) -> None: """ Use-case: issue_51(os.get_handle_inheritable, os.set_handle_inheritable) """ def issue_73_utf8_doc_chars() -> None: """ Construct a Ramsete unicycle controller. Tuning parameter (b > 0 rad²/m²) for which larger values make convergence more aggressive like a proportional term. Tuning parameter (0 rad⁻¹ < zeta < 1 rad⁻¹) for which larger values provide more damping in response. """ _cleanup: typing.Any # value = methods.pyi000066400000000000000000000003041525537303700366540ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations __all__: list[str] = ["Dummy"] class Dummy: @staticmethod def static_method(arg0: int) -> int: ... def regular_method(self, arg0: int) -> int: ... numpy.pyi000066400000000000000000000012101525537303700363560ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import typing import numpy __all__: list[str] = [ "accept_ndarray_float64", "accept_ndarray_int", "get_ndarray_float64", "get_ndarray_int", "return_dtype", ] def accept_ndarray_float64( arg0: numpy.ndarray[typing.Any, numpy.dtype[numpy.float64]], ) -> None: ... def accept_ndarray_int( arg0: numpy.ndarray[typing.Any, numpy.dtype[numpy.int32]], ) -> None: ... def get_ndarray_float64() -> numpy.ndarray[typing.Any, numpy.dtype[numpy.float64]]: ... def get_ndarray_int() -> numpy.ndarray[typing.Any, numpy.dtype[numpy.int32]]: ... def return_dtype() -> numpy.dtype[typing.Any]: ... properties.pyi000066400000000000000000000050711525537303700374130ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "WithGetterSetterDoc", "WithPropAndGetterSetterDoc", "WithPropDoc", "WithoutDoc", ] class WithoutDoc: """ No user docstring provided """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 def_property: int def_readwrite: int @property def def_property_readonly(self) -> int: ... @property def def_readonly(self) -> int: ... class WithPropDoc: """ User docstring provided only to `def_` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 """ prop doc token """ def_property_static: typing.ClassVar[int] = 0 """ prop doc token """ @property def def_property(self) -> int: """ prop doc token """ @def_property.setter def def_property(self, arg1: int) -> None: ... @property def def_property_readonly(self) -> int: """ prop doc token """ @property def def_readonly(self) -> int: """ prop doc token """ @property def def_readwrite(self) -> int: """ prop doc token """ @def_readwrite.setter def def_readwrite(self, arg0: int) -> None: ... class WithGetterSetterDoc: """ User docstring provided via pybind11::cpp_function(..., doc) to getters/setters, but NOT to `def_*(..., doc)` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 """ getter doc token """ def_property_static: typing.ClassVar[int] = 0 """ getter doc token """ @property def def_property(self) -> int: """ getter doc token """ @def_property.setter def def_property(self, arg1: int) -> None: """ setter doc token """ @property def def_property_readonly(self) -> int: """ getter doc token """ class WithPropAndGetterSetterDoc: """ User docstring provided via pybind11::cpp_function(..., doc) to getters/setters and to `def_*(, doc)` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 """ prop doc token """ def_property_static: typing.ClassVar[int] = 0 """ prop doc token """ @property def def_property(self) -> int: """ prop doc token """ @def_property.setter def def_property(self, arg1: int) -> None: ... @property def def_property_readonly(self) -> int: """ prop doc token """ stl.pyi000066400000000000000000000011061525537303700360140ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import typing import pybind11_stubgen.typing_ext __all__: list[str] = [ "std_array", "std_map", "std_optional", "std_variant", "std_vector", ] def std_array( arg0: typing.Annotated[list[int], pybind11_stubgen.typing_ext.FixedSize(3)], ) -> typing.Annotated[list[int], pybind11_stubgen.typing_ext.FixedSize(3)]: ... def std_map() -> dict[int, complex]: ... def std_optional(arg0: int | None) -> None: ... def std_variant(arg0: int | float | tuple[int, int]) -> None: ... def std_vector() -> list[tuple[int, float]]: ... stl_bind.pyi000066400000000000000000000075471525537303700370270ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "MapStringComplex", "VectorPairStringDouble", "get_complex_map", "get_vector_of_pairs", ] class VectorPairStringDouble: __hash__: typing.ClassVar[None] = None def __bool__(self) -> bool: """ Check whether the list is nonempty """ def __contains__(self, x: tuple[str, float]) -> bool: """ Return true the container contains ``x`` """ @typing.overload def __delitem__(self, arg0: int) -> None: """ Delete the list elements at index ``i`` """ @typing.overload def __delitem__(self, arg0: slice) -> None: """ Delete list elements using a slice object """ def __eq__(self, arg0: VectorPairStringDouble) -> bool: ... @typing.overload def __getitem__(self, s: slice) -> VectorPairStringDouble: """ Retrieve list elements using a slice object """ @typing.overload def __getitem__(self, arg0: int) -> tuple[str, float]: ... @typing.overload def __init__(self) -> None: ... @typing.overload def __init__(self, arg0: VectorPairStringDouble) -> None: """ Copy constructor """ @typing.overload def __init__(self, arg0: typing.Iterable) -> None: ... def __iter__(self) -> typing.Iterator[tuple[str, float]]: ... def __len__(self) -> int: ... def __ne__(self, arg0: VectorPairStringDouble) -> bool: ... @typing.overload def __setitem__(self, arg0: int, arg1: tuple[str, float]) -> None: ... @typing.overload def __setitem__(self, arg0: slice, arg1: VectorPairStringDouble) -> None: """ Assign list elements using a slice object """ def append(self, x: tuple[str, float]) -> None: """ Add an item to the end of the list """ def clear(self) -> None: """ Clear the contents """ def count(self, x: tuple[str, float]) -> int: """ Return the number of times ``x`` appears in the list """ @typing.overload def extend(self, L: VectorPairStringDouble) -> None: """ Extend the list by appending all the items in the given list """ @typing.overload def extend(self, L: typing.Iterable) -> None: """ Extend the list by appending all the items in the given list """ def insert(self, i: int, x: tuple[str, float]) -> None: """ Insert an item at a given position. """ @typing.overload def pop(self) -> tuple[str, float]: """ Remove and return the last item """ @typing.overload def pop(self, i: int) -> tuple[str, float]: """ Remove and return the item at index ``i`` """ def remove(self, x: tuple[str, float]) -> None: """ Remove the first item from the list whose value is x. It is an error if there is no such item. """ class MapStringComplex: def __bool__(self) -> bool: """ Check whether the map is nonempty """ @typing.overload def __contains__(self, arg0: str) -> bool: ... @typing.overload def __contains__(self, arg0: typing.Any) -> bool: ... def __delitem__(self, arg0: str) -> None: ... def __getitem__(self, arg0: str) -> complex: ... def __init__(self) -> None: ... def __iter__(self) -> typing.Iterator[str]: ... def __len__(self) -> int: ... def __repr__(self) -> str: """ Return the canonical string representation of this map. """ def __setitem__(self, arg0: str, arg1: complex) -> None: ... def items(self) -> typing.ItemsView: ... def keys(self) -> typing.KeysView: ... def values(self) -> typing.ValuesView: ... def get_complex_map() -> MapStringComplex: ... def get_vector_of_pairs() -> VectorPairStringDouble: ... typing.pyi000066400000000000000000000004221525537303700365240ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import typing import typing_extensions __all__: list[str] = ["get_buffer", "get_sequence"] def get_buffer(arg0: typing_extensions.Buffer) -> typing_extensions.Buffer: ... def get_sequence(arg0: typing.Sequence) -> typing.Sequence: ... values.pyi000066400000000000000000000014521525537303700365150ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import datetime import numpy from numpy import random __all__: list[str] = [ "Dummy", "Foo", "add_day", "foolist", "foovar", "list_with_none", "none", "random", "t_10ms", "t_20ns", "t_30s", ] class Dummy: linalg = numpy.linalg class Foo: pass def add_day(arg0: datetime.datetime) -> datetime.datetime: ... foolist: list # value = [, ] foovar: Foo # value = list_with_none: list = [None, 2, {}] none = None t_10ms: datetime.timedelta # value = datetime.timedelta(microseconds=10000) t_20ns: datetime.timedelta # value = datetime.timedelta(0) t_30s: datetime.timedelta # value = datetime.timedelta(seconds=30) core.pyi000066400000000000000000000010211525537303700342020ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-use-type-var/demofrom __future__ import annotations from demo._bindings import ( aliases, classes, eigen, enum, flawed_bindings, functions, hidden_builtins, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) __all__: list[str] = [ "aliases", "classes", "eigen", "enum", "flawed_bindings", "functions", "hidden_builtins", "issues", "methods", "numpy", "properties", "stl", "stl_bind", "typing", "values", ] pure_python/000077500000000000000000000000001525537303700351115ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-use-type-var/demo__init__.pyi000066400000000000000000000003611525537303700373730ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-use-type-var/demo/pure_pythonfrom __future__ import annotations from . import classes, functions, functions_3_8_plus, functions_3_9_plus, values __all__: list[str] = [ "classes", "functions", "functions_3_8_plus", "functions_3_9_plus", "values", ] classes.pyi000066400000000000000000000003071525537303700372710ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-use-type-var/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["A", "B", "C", "X"] class A: """ A """ class B(A): """ B """ class C(B): """ C """ class X: pass functions.pyi000066400000000000000000000015561525537303700376530ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-use-type-var/demo/pure_pythonfrom __future__ import annotations import sys as sys import typing as typing from demo.pure_python.functions_3_8_plus import args_mix from demo.pure_python.functions_3_9_plus import generic_alias_annotation __all__: list[str] = [ "accept_frozenset", "args_mix", "builtin_function_as_default_arg", "function_as_default_arg", "generic_alias_annotation", "lambda_as_default_arg", "search", "static_method_as_default_arg", "sys", "typing", ] class _Dummy: @staticmethod def foo(): ... def accept_frozenset(arg: frozenset[int | float]) -> int | None: ... def builtin_function_as_default_arg(func: type(len) = len): ... def function_as_default_arg(func: type(search) = search): ... def lambda_as_default_arg(callback=...): ... def search(a: int, b: list[int]) -> int: ... def static_method_as_default_arg(callback=_Dummy.foo): ... functions_3_8_plus.pyi000066400000000000000000000007761525537303700413720ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-use-type-var/demo/pure_pythonfrom __future__ import annotations import typing as typing __all__: list[str] = [ "Expression", "Token", "args_mix", "nested_current_module_annotations", "typing", ] class Token: pass class Expression: pass def args_mix( a: int, b: float = 0.5, c: str = "", *args: int, x: int = 1, y=int, **kwargs: dict[int, str], ): ... def nested_current_module_annotations( tokens: list[Token], expr: Expression | None = None ) -> dict[str, Expression]: ... functions_3_9_plus.pyi000066400000000000000000000002601525537303700413570ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-use-type-var/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["generic_alias_annotation"] def generic_alias_annotation(a: list[tuple[int]], b: dict[int, str]) -> list[float]: ... values.pyi000066400000000000000000000001741525537303700371350ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-use-type-var/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["callables_dict"] callables_dict: dict = {"len": len, "int": int} numpy-array-wrap-with-annotated/000077500000000000000000000000001525537303700331455ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13demo/000077500000000000000000000000001525537303700340715ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-wrap-with-annotated__init__.pyi000066400000000000000000000012021525537303700363460ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-wrap-with-annotated/demofrom __future__ import annotations from demo._bindings import ( aliases, classes, eigen, enum, flawed_bindings, functions, hidden_builtins, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) from . import _bindings, core, pure_python __all__: list[str] = [ "aliases", "classes", "core", "eigen", "enum", "flawed_bindings", "functions", "hidden_builtins", "issues", "methods", "numpy", "properties", "pure_python", "stl", "stl_bind", "typing", "values", "version", ] version: str = "0.0.0" _bindings/000077500000000000000000000000001525537303700360255ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-wrap-with-annotated/demo__init__.pyi000066400000000000000000000010041525537303700403020ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations from . import ( aliases, classes, eigen, enum, flawed_bindings, functions, hidden_builtins, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) __all__: list[str] = [ "aliases", "classes", "eigen", "enum", "flawed_bindings", "functions", "hidden_builtins", "issues", "methods", "numpy", "properties", "stl", "stl_bind", "typing", "values", ] aliases/000077500000000000000000000000001525537303700374465ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindings__init__.pyi000066400000000000000000000020761525537303700417350ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import typing import demo._bindings.enum import numpy from demo._bindings.aliases.foreign_method_arg import Bar2 as foreign_type_alias from demo._bindings.aliases.foreign_return import get_foo as foreign_class_alias from numpy import random from . import ( foreign_arg, foreign_attr, foreign_class_member, foreign_method_arg, foreign_method_return, foreign_return, missing_self_arg, ) __all__: list[str] = [ "Color", "Dummy", "foreign_arg", "foreign_attr", "foreign_class_alias", "foreign_class_member", "foreign_enum_default", "foreign_method_arg", "foreign_method_return", "foreign_return", "foreign_type_alias", "func", "local_func_alias", "local_type_alias", "missing_self_arg", "random", ] class Dummy: linalg = numpy.linalg class Color: pass def foreign_enum_default( color: typing.Any = demo._bindings.enum.ConsoleForegroundColor.Blue, ) -> None: ... def func(arg0: int) -> int: ... local_type_alias = Color local_func_alias = func foreign_arg.pyi000066400000000000000000000002371525537303700424550ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["set_foo"] def set_foo(arg0: demo._bindings.classes.Foo) -> int: ... foreign_attr.pyi000066400000000000000000000002631525537303700426550ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["value"] value: demo._bindings.classes.Foo # value = foreign_class_member.pyi000066400000000000000000000003571525537303700443430ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import typing import demo._bindings.classes __all__: list[str] = ["Bar1"] class Bar1: foo: typing.ClassVar[ demo._bindings.classes.Foo ] # value = foreign_method_arg.pyi000066400000000000000000000002621525537303700440130ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar2"] class Bar2: def set_foo(self, arg0: demo._bindings.classes.Foo) -> int: ... foreign_method_return.pyi000066400000000000000000000002651525537303700445640ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar3"] class Bar3: @staticmethod def get_foo() -> demo._bindings.classes.Foo: ... foreign_return.pyi000066400000000000000000000002261525537303700432210ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["get_foo"] def get_foo() -> demo._bindings.classes.Foo: ... missing_self_arg.pyi000066400000000000000000000002541525537303700435050ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar4"] class Bar4: def set_foo(self: demo._bindings.classes.Foo) -> int: ... classes.pyi000066400000000000000000000036571525537303700402200ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "CppException", "Derived", "Foo", "MyBase", "Outer", "ParIter", "ParIterBase", "ParticleContainer", ] class Outer: class Inner: class NestedEnum: """ Members: ONE TWO """ ONE: typing.ClassVar[Outer.Inner.NestedEnum] # value = TWO: typing.ClassVar[Outer.Inner.NestedEnum] # value = __members__: typing.ClassVar[ dict[str, Outer.Inner.NestedEnum] ] # value = {'ONE': , 'TWO': } def __eq__(self, other: typing.Any) -> bool: ... def __getstate__(self) -> int: ... def __hash__(self) -> int: ... def __index__(self) -> int: ... def __init__(self, value: int) -> None: ... def __int__(self) -> int: ... def __ne__(self, other: typing.Any) -> bool: ... def __repr__(self) -> str: ... def __setstate__(self, state: int) -> None: ... def __str__(self) -> str: ... @property def name(self) -> str: ... @property def value(self) -> int: ... value: Outer.Inner.NestedEnum inner: Outer.Inner class MyBase: class Inner: pass name: str class Derived(MyBase): count: int class Foo: class FooChild: def __init__(self) -> None: ... def g(self) -> None: ... def __init__(self) -> None: ... def f(self) -> None: ... class ParIterBase: level: int class ParIter(ParIterBase): def __init__(self, particle_container: ParticleContainer, level: int) -> None: ... class ParticleContainer: name: str Iterator = ParIter def process(self, arg0: ParIter) -> None: ... class CppException(Exception): pass eigen.pyi000066400000000000000000000060031525537303700376360ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing import numpy import scipy.sparse import pybind11_stubgen.typing_ext __all__: list[str] = [ "accept_matrix_int", "accept_vector_float64", "dense_matrix_c", "dense_matrix_r", "fixed_mutator_a", "fixed_mutator_c", "fixed_mutator_r", "four_col_matrix_r", "four_row_matrix_r", "get_matrix_int", "get_vector_float64", "sparse_matrix_c", "sparse_matrix_r", ] def accept_matrix_int( arg0: typing.Annotated[ numpy.ndarray, numpy.int32, pybind11_stubgen.typing_ext.FixedSize(3, 3) ], ) -> None: ... def accept_vector_float64( arg0: typing.Annotated[ numpy.ndarray, numpy.float64, pybind11_stubgen.typing_ext.FixedSize(3, 1) ], ) -> None: ... def dense_matrix_c( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", "n") ], ) -> typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", "n") ]: ... def dense_matrix_r( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", "n") ], ) -> typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", "n") ]: ... def fixed_mutator_a( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.FixedSize(5, 6), numpy.ndarray.flags.writeable, ], ) -> None: ... def fixed_mutator_c( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.FixedSize(5, 6), numpy.ndarray.flags.writeable, numpy.ndarray.flags.f_contiguous, ], ) -> None: ... def fixed_mutator_r( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.FixedSize(5, 6), numpy.ndarray.flags.writeable, numpy.ndarray.flags.c_contiguous, ], ) -> None: ... def four_col_matrix_r( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", 4) ], ) -> typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", 4) ]: ... def four_row_matrix_r( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize(4, "n") ], ) -> typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize(4, "n") ]: ... def get_matrix_int() -> typing.Annotated[ numpy.ndarray, numpy.int32, pybind11_stubgen.typing_ext.FixedSize(3, 3) ]: ... def get_vector_float64() -> typing.Annotated[ numpy.ndarray, numpy.float64, pybind11_stubgen.typing_ext.FixedSize(3, 1) ]: ... def sparse_matrix_c( arg0: typing.Annotated[scipy.sparse.csc_matrix, numpy.float32], ) -> typing.Annotated[scipy.sparse.csc_matrix, numpy.float32]: ... def sparse_matrix_r( arg0: typing.Annotated[scipy.sparse.csr_matrix, numpy.float32], ) -> typing.Annotated[scipy.sparse.csr_matrix, numpy.float32]: ... enum.pyi000066400000000000000000000042501525537303700375150ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "Blue", "ConsoleForegroundColor", "Green", "Magenta", "None_", "Yellow", "accept_defaulted_enum", ] class ConsoleForegroundColor: """ Members: Green Yellow Blue Magenta None_ """ Blue: typing.ClassVar[ ConsoleForegroundColor ] # value = Green: typing.ClassVar[ ConsoleForegroundColor ] # value = Magenta: typing.ClassVar[ ConsoleForegroundColor ] # value = None_: typing.ClassVar[ ConsoleForegroundColor ] # value = Yellow: typing.ClassVar[ ConsoleForegroundColor ] # value = __members__: typing.ClassVar[ dict[str, ConsoleForegroundColor] ] # value = {'Green': , 'Yellow': , 'Blue': , 'Magenta': , 'None_': } def __eq__(self, other: typing.Any) -> bool: ... def __getstate__(self) -> int: ... def __hash__(self) -> int: ... def __index__(self) -> int: ... def __init__(self, value: int) -> None: ... def __int__(self) -> int: ... def __ne__(self, other: typing.Any) -> bool: ... def __repr__(self) -> str: ... def __setstate__(self, state: int) -> None: ... def __str__(self) -> str: ... @property def name(self) -> str: ... @property def value(self) -> int: ... def accept_defaulted_enum( color: ConsoleForegroundColor = ConsoleForegroundColor.None_, ) -> None: ... Blue: ConsoleForegroundColor # value = Green: ConsoleForegroundColor # value = Magenta: ConsoleForegroundColor # value = None_: ConsoleForegroundColor # value = Yellow: ConsoleForegroundColor # value = flawed_bindings.pyi000066400000000000000000000010521525537303700416650ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations __all__: list[str] = [ "Enum", "Unbound", "accept_unbound_enum", "accept_unbound_enum_defaulted", "accept_unbound_type", "accept_unbound_type_defaulted", "get_unbound_type", ] class Unbound: pass class Enum: pass def accept_unbound_enum(arg0: ...) -> int: ... def accept_unbound_enum_defaulted(x: Enum = ...) -> int: ... def accept_unbound_type(arg0: tuple[..., int]) -> int: ... def accept_unbound_type_defaulted(x: Unbound = ...) -> int: ... def get_unbound_type() -> ...: ... functions.pyi000066400000000000000000000044231525537303700405630ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "Foo", "accept_annotated_callable", "accept_callable", "accept_frozenset", "accept_py_handle", "accept_py_object", "accept_set", "add", "default_custom_arg", "default_int_arg", "default_list_arg", "default_optional_arg", "func_w_anon_args", "func_w_named_pos_args", "generic", "mul", "nested_types", "pass_callback", "passthrough1", "passthrough2", "passthrough3", "passthrough_backwards", "pos_kw_only_mix", "pos_kw_only_variadic_mix", ] class Foo: def __init__(self, arg0: int) -> None: ... def accept_annotated_callable(arg0: typing.Callable[[int, int], int]) -> typing.Any: ... def accept_callable(arg0: typing.Callable) -> typing.Any: ... def accept_frozenset(arg0: frozenset) -> None: ... def accept_py_handle(arg0: typing.Any) -> str: ... def accept_py_object(arg0: typing.Any) -> str: ... def accept_set(arg0: set) -> None: ... def add(arg0: int, arg1: int) -> int: ... def default_custom_arg(foo: Foo = Foo(5)) -> None: ... def default_int_arg(n: int = 5) -> None: ... def default_list_arg(l: list = [1, 2, 6, 18]) -> None: ... def default_optional_arg(n: int | None = None) -> None: ... def func_w_anon_args(arg0: int, arg1: int, arg2: int) -> None: ... def func_w_named_pos_args(x: int, y: int, z: int) -> None: ... def generic(*args, **kwargs) -> None: ... @typing.overload def mul(x: int, y: int) -> int: """ Multiply x and y (int) """ @typing.overload def mul(p: float, q: float) -> float: """ Multiply p and q (double) """ def nested_types(arg0: list[Foo] | Foo) -> list[Foo] | Foo: ... def pass_callback(arg0: typing.Callable[[Foo], Foo]) -> Foo: ... def passthrough1[T](obj: T) -> T: ... @typing.overload def passthrough2() -> None: ... @typing.overload def passthrough2[T](obj: T) -> T: ... @typing.overload def passthrough3() -> tuple[None, None]: ... @typing.overload def passthrough3[T](obj: T) -> tuple[T, None]: ... @typing.overload def passthrough3[T1, T2](obj1: T1, obj2: T2) -> tuple[T1, T2]: ... def passthrough_backwards[T](obj: T) -> T: ... def pos_kw_only_mix(i: int, /, j: int, *, k: int) -> tuple: ... def pos_kw_only_variadic_mix(i: int, /, j: int, *args, k: int, **kwargs) -> tuple: ... hidden_builtins.pyi000066400000000000000000000002571525537303700417200ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import types __all__: list[str] = ["mapping_proxy", "none"] mapping_proxy: types.MappingProxyType # value = mappingproxy({}) none = None issues.pyi000066400000000000000000000021111525537303700400560ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "backslashes_should_be_escaped", "issue_51_catastrophic_regex", "issue_73_utf8_doc_chars", "issue_274_docstring_leading_newline", ] def backslashes_should_be_escaped() -> None: """ \\brief A brief description of this function. A detailed description of this function. Here's some reStructuredText: :math:`x = [x, y, \\theta]^T` """ def issue_274_docstring_leading_newline() -> None: """ This is a docstring """ def issue_51_catastrophic_regex(arg0: int, arg1: int) -> None: """ Use-case: issue_51(os.get_handle_inheritable, os.set_handle_inheritable) """ def issue_73_utf8_doc_chars() -> None: """ Construct a Ramsete unicycle controller. Tuning parameter (b > 0 rad²/m²) for which larger values make convergence more aggressive like a proportional term. Tuning parameter (0 rad⁻¹ < zeta < 1 rad⁻¹) for which larger values provide more damping in response. """ _cleanup: typing.Any # value = methods.pyi000066400000000000000000000003041525537303700402100ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations __all__: list[str] = ["Dummy"] class Dummy: @staticmethod def static_method(arg0: int) -> int: ... def regular_method(self, arg0: int) -> int: ... numpy.pyi000066400000000000000000000011451525537303700377210ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing import numpy __all__: list[str] = [ "accept_ndarray_float64", "accept_ndarray_int", "get_ndarray_float64", "get_ndarray_int", "return_dtype", ] def accept_ndarray_float64( arg0: typing.Annotated[numpy.ndarray, numpy.float64], ) -> None: ... def accept_ndarray_int(arg0: typing.Annotated[numpy.ndarray, numpy.int32]) -> None: ... def get_ndarray_float64() -> typing.Annotated[numpy.ndarray, numpy.float64]: ... def get_ndarray_int() -> typing.Annotated[numpy.ndarray, numpy.int32]: ... def return_dtype() -> numpy.dtype[typing.Any]: ... properties.pyi000066400000000000000000000050711525537303700407470ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "WithGetterSetterDoc", "WithPropAndGetterSetterDoc", "WithPropDoc", "WithoutDoc", ] class WithoutDoc: """ No user docstring provided """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 def_property: int def_readwrite: int @property def def_property_readonly(self) -> int: ... @property def def_readonly(self) -> int: ... class WithPropDoc: """ User docstring provided only to `def_` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 """ prop doc token """ def_property_static: typing.ClassVar[int] = 0 """ prop doc token """ @property def def_property(self) -> int: """ prop doc token """ @def_property.setter def def_property(self, arg1: int) -> None: ... @property def def_property_readonly(self) -> int: """ prop doc token """ @property def def_readonly(self) -> int: """ prop doc token """ @property def def_readwrite(self) -> int: """ prop doc token """ @def_readwrite.setter def def_readwrite(self, arg0: int) -> None: ... class WithGetterSetterDoc: """ User docstring provided via pybind11::cpp_function(..., doc) to getters/setters, but NOT to `def_*(..., doc)` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 """ getter doc token """ def_property_static: typing.ClassVar[int] = 0 """ getter doc token """ @property def def_property(self) -> int: """ getter doc token """ @def_property.setter def def_property(self, arg1: int) -> None: """ setter doc token """ @property def def_property_readonly(self) -> int: """ getter doc token """ class WithPropAndGetterSetterDoc: """ User docstring provided via pybind11::cpp_function(..., doc) to getters/setters and to `def_*(, doc)` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 """ prop doc token """ def_property_static: typing.ClassVar[int] = 0 """ prop doc token """ @property def def_property(self) -> int: """ prop doc token """ @def_property.setter def def_property(self, arg1: int) -> None: ... @property def def_property_readonly(self) -> int: """ prop doc token """ stl.pyi000066400000000000000000000011061525537303700373500ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing import pybind11_stubgen.typing_ext __all__: list[str] = [ "std_array", "std_map", "std_optional", "std_variant", "std_vector", ] def std_array( arg0: typing.Annotated[list[int], pybind11_stubgen.typing_ext.FixedSize(3)], ) -> typing.Annotated[list[int], pybind11_stubgen.typing_ext.FixedSize(3)]: ... def std_map() -> dict[int, complex]: ... def std_optional(arg0: int | None) -> None: ... def std_variant(arg0: int | float | tuple[int, int]) -> None: ... def std_vector() -> list[tuple[int, float]]: ... stl_bind.pyi000066400000000000000000000075471525537303700403630ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "MapStringComplex", "VectorPairStringDouble", "get_complex_map", "get_vector_of_pairs", ] class VectorPairStringDouble: __hash__: typing.ClassVar[None] = None def __bool__(self) -> bool: """ Check whether the list is nonempty """ def __contains__(self, x: tuple[str, float]) -> bool: """ Return true the container contains ``x`` """ @typing.overload def __delitem__(self, arg0: int) -> None: """ Delete the list elements at index ``i`` """ @typing.overload def __delitem__(self, arg0: slice) -> None: """ Delete list elements using a slice object """ def __eq__(self, arg0: VectorPairStringDouble) -> bool: ... @typing.overload def __getitem__(self, s: slice) -> VectorPairStringDouble: """ Retrieve list elements using a slice object """ @typing.overload def __getitem__(self, arg0: int) -> tuple[str, float]: ... @typing.overload def __init__(self) -> None: ... @typing.overload def __init__(self, arg0: VectorPairStringDouble) -> None: """ Copy constructor """ @typing.overload def __init__(self, arg0: typing.Iterable) -> None: ... def __iter__(self) -> typing.Iterator[tuple[str, float]]: ... def __len__(self) -> int: ... def __ne__(self, arg0: VectorPairStringDouble) -> bool: ... @typing.overload def __setitem__(self, arg0: int, arg1: tuple[str, float]) -> None: ... @typing.overload def __setitem__(self, arg0: slice, arg1: VectorPairStringDouble) -> None: """ Assign list elements using a slice object """ def append(self, x: tuple[str, float]) -> None: """ Add an item to the end of the list """ def clear(self) -> None: """ Clear the contents """ def count(self, x: tuple[str, float]) -> int: """ Return the number of times ``x`` appears in the list """ @typing.overload def extend(self, L: VectorPairStringDouble) -> None: """ Extend the list by appending all the items in the given list """ @typing.overload def extend(self, L: typing.Iterable) -> None: """ Extend the list by appending all the items in the given list """ def insert(self, i: int, x: tuple[str, float]) -> None: """ Insert an item at a given position. """ @typing.overload def pop(self) -> tuple[str, float]: """ Remove and return the last item """ @typing.overload def pop(self, i: int) -> tuple[str, float]: """ Remove and return the item at index ``i`` """ def remove(self, x: tuple[str, float]) -> None: """ Remove the first item from the list whose value is x. It is an error if there is no such item. """ class MapStringComplex: def __bool__(self) -> bool: """ Check whether the map is nonempty """ @typing.overload def __contains__(self, arg0: str) -> bool: ... @typing.overload def __contains__(self, arg0: typing.Any) -> bool: ... def __delitem__(self, arg0: str) -> None: ... def __getitem__(self, arg0: str) -> complex: ... def __init__(self) -> None: ... def __iter__(self) -> typing.Iterator[str]: ... def __len__(self) -> int: ... def __repr__(self) -> str: """ Return the canonical string representation of this map. """ def __setitem__(self, arg0: str, arg1: complex) -> None: ... def items(self) -> typing.ItemsView: ... def keys(self) -> typing.KeysView: ... def values(self) -> typing.ValuesView: ... def get_complex_map() -> MapStringComplex: ... def get_vector_of_pairs() -> VectorPairStringDouble: ... typing.pyi000066400000000000000000000004221525537303700400600ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing import typing_extensions __all__: list[str] = ["get_buffer", "get_sequence"] def get_buffer(arg0: typing_extensions.Buffer) -> typing_extensions.Buffer: ... def get_sequence(arg0: typing.Sequence) -> typing.Sequence: ... values.pyi000066400000000000000000000014521525537303700400510ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import datetime import numpy from numpy import random __all__: list[str] = [ "Dummy", "Foo", "add_day", "foolist", "foovar", "list_with_none", "none", "random", "t_10ms", "t_20ns", "t_30s", ] class Dummy: linalg = numpy.linalg class Foo: pass def add_day(arg0: datetime.datetime) -> datetime.datetime: ... foolist: list # value = [, ] foovar: Foo # value = list_with_none: list = [None, 2, {}] none = None t_10ms: datetime.timedelta # value = datetime.timedelta(microseconds=10000) t_20ns: datetime.timedelta # value = datetime.timedelta(0) t_30s: datetime.timedelta # value = datetime.timedelta(seconds=30) core.pyi000066400000000000000000000010211525537303700355360ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-wrap-with-annotated/demofrom __future__ import annotations from demo._bindings import ( aliases, classes, eigen, enum, flawed_bindings, functions, hidden_builtins, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) __all__: list[str] = [ "aliases", "classes", "eigen", "enum", "flawed_bindings", "functions", "hidden_builtins", "issues", "methods", "numpy", "properties", "stl", "stl_bind", "typing", "values", ] pure_python/000077500000000000000000000000001525537303700364455ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-wrap-with-annotated/demo__init__.pyi000066400000000000000000000003611525537303700407270ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations from . import classes, functions, functions_3_8_plus, functions_3_9_plus, values __all__: list[str] = [ "classes", "functions", "functions_3_8_plus", "functions_3_9_plus", "values", ] classes.pyi000066400000000000000000000003071525537303700406250ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["A", "B", "C", "X"] class A: """ A """ class B(A): """ B """ class C(B): """ C """ class X: pass functions.pyi000066400000000000000000000015561525537303700412070ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations import sys as sys import typing as typing from demo.pure_python.functions_3_8_plus import args_mix from demo.pure_python.functions_3_9_plus import generic_alias_annotation __all__: list[str] = [ "accept_frozenset", "args_mix", "builtin_function_as_default_arg", "function_as_default_arg", "generic_alias_annotation", "lambda_as_default_arg", "search", "static_method_as_default_arg", "sys", "typing", ] class _Dummy: @staticmethod def foo(): ... def accept_frozenset(arg: frozenset[int | float]) -> int | None: ... def builtin_function_as_default_arg(func: type(len) = len): ... def function_as_default_arg(func: type(search) = search): ... def lambda_as_default_arg(callback=...): ... def search(a: int, b: list[int]) -> int: ... def static_method_as_default_arg(callback=_Dummy.foo): ... functions_3_8_plus.pyi000066400000000000000000000007761525537303700427260ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations import typing as typing __all__: list[str] = [ "Expression", "Token", "args_mix", "nested_current_module_annotations", "typing", ] class Token: pass class Expression: pass def args_mix( a: int, b: float = 0.5, c: str = "", *args: int, x: int = 1, y=int, **kwargs: dict[int, str], ): ... def nested_current_module_annotations( tokens: list[Token], expr: Expression | None = None ) -> dict[str, Expression]: ... functions_3_9_plus.pyi000066400000000000000000000002601525537303700427130ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["generic_alias_annotation"] def generic_alias_annotation(a: list[tuple[int]], b: dict[int, str]) -> list[float]: ... values.pyi000066400000000000000000000001741525537303700404710ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["callables_dict"] callables_dict: dict = {"len": len, "int": int} pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9/000077500000000000000000000000001525537303700247725ustar00rootroot00000000000000numpy-array-wrap-with-annotated/000077500000000000000000000000001525537303700330725ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9demo/000077500000000000000000000000001525537303700340165ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9/numpy-array-wrap-with-annotated__init__.pyi000066400000000000000000000012021525537303700362730ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9/numpy-array-wrap-with-annotated/demofrom __future__ import annotations from demo._bindings import ( aliases, classes, eigen, enum, flawed_bindings, functions, hidden_builtins, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) from . import _bindings, core, pure_python __all__: list[str] = [ "aliases", "classes", "core", "eigen", "enum", "flawed_bindings", "functions", "hidden_builtins", "issues", "methods", "numpy", "properties", "pure_python", "stl", "stl_bind", "typing", "values", "version", ] version: str = "0.0.0" _bindings/000077500000000000000000000000001525537303700357525ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9/numpy-array-wrap-with-annotated/demo__init__.pyi000066400000000000000000000010041525537303700402270ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations from . import ( aliases, classes, eigen, enum, flawed_bindings, functions, hidden_builtins, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) __all__: list[str] = [ "aliases", "classes", "eigen", "enum", "flawed_bindings", "functions", "hidden_builtins", "issues", "methods", "numpy", "properties", "stl", "stl_bind", "typing", "values", ] aliases/000077500000000000000000000000001525537303700373735ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindings__init__.pyi000066400000000000000000000020761525537303700416620ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import typing import demo._bindings.enum import numpy from demo._bindings.aliases.foreign_method_arg import Bar2 as foreign_type_alias from demo._bindings.aliases.foreign_return import get_foo as foreign_class_alias from numpy import random from . import ( foreign_arg, foreign_attr, foreign_class_member, foreign_method_arg, foreign_method_return, foreign_return, missing_self_arg, ) __all__: list[str] = [ "Color", "Dummy", "foreign_arg", "foreign_attr", "foreign_class_alias", "foreign_class_member", "foreign_enum_default", "foreign_method_arg", "foreign_method_return", "foreign_return", "foreign_type_alias", "func", "local_func_alias", "local_type_alias", "missing_self_arg", "random", ] class Dummy: linalg = numpy.linalg class Color: pass def foreign_enum_default( color: typing.Any = demo._bindings.enum.ConsoleForegroundColor.Blue, ) -> None: ... def func(arg0: int) -> int: ... local_type_alias = Color local_func_alias = func foreign_arg.pyi000066400000000000000000000002371525537303700424020ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["set_foo"] def set_foo(arg0: demo._bindings.classes.Foo) -> int: ... foreign_attr.pyi000066400000000000000000000002631525537303700426020ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["value"] value: demo._bindings.classes.Foo # value = foreign_class_member.pyi000066400000000000000000000003571525537303700442700ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import typing import demo._bindings.classes __all__: list[str] = ["Bar1"] class Bar1: foo: typing.ClassVar[ demo._bindings.classes.Foo ] # value = foreign_method_arg.pyi000066400000000000000000000002621525537303700437400ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar2"] class Bar2: def set_foo(self, arg0: demo._bindings.classes.Foo) -> int: ... foreign_method_return.pyi000066400000000000000000000002651525537303700445110ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar3"] class Bar3: @staticmethod def get_foo() -> demo._bindings.classes.Foo: ... foreign_return.pyi000066400000000000000000000002261525537303700431460ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["get_foo"] def get_foo() -> demo._bindings.classes.Foo: ... missing_self_arg.pyi000066400000000000000000000002541525537303700434320ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar4"] class Bar4: def set_foo(self: demo._bindings.classes.Foo) -> int: ... classes.pyi000066400000000000000000000036571525537303700401450ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "CppException", "Derived", "Foo", "MyBase", "Outer", "ParIter", "ParIterBase", "ParticleContainer", ] class Outer: class Inner: class NestedEnum: """ Members: ONE TWO """ ONE: typing.ClassVar[Outer.Inner.NestedEnum] # value = TWO: typing.ClassVar[Outer.Inner.NestedEnum] # value = __members__: typing.ClassVar[ dict[str, Outer.Inner.NestedEnum] ] # value = {'ONE': , 'TWO': } def __eq__(self, other: typing.Any) -> bool: ... def __getstate__(self) -> int: ... def __hash__(self) -> int: ... def __index__(self) -> int: ... def __init__(self, value: int) -> None: ... def __int__(self) -> int: ... def __ne__(self, other: typing.Any) -> bool: ... def __repr__(self) -> str: ... def __setstate__(self, state: int) -> None: ... def __str__(self) -> str: ... @property def name(self) -> str: ... @property def value(self) -> int: ... value: Outer.Inner.NestedEnum inner: Outer.Inner class MyBase: class Inner: pass name: str class Derived(MyBase): count: int class Foo: class FooChild: def __init__(self) -> None: ... def g(self) -> None: ... def __init__(self) -> None: ... def f(self) -> None: ... class ParIterBase: level: int class ParIter(ParIterBase): def __init__(self, particle_container: ParticleContainer, level: int) -> None: ... class ParticleContainer: name: str Iterator = ParIter def process(self, arg0: ParIter) -> None: ... class CppException(Exception): pass eigen.pyi000066400000000000000000000060031525537303700375630ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing import numpy import scipy.sparse import pybind11_stubgen.typing_ext __all__: list[str] = [ "accept_matrix_int", "accept_vector_float64", "dense_matrix_c", "dense_matrix_r", "fixed_mutator_a", "fixed_mutator_c", "fixed_mutator_r", "four_col_matrix_r", "four_row_matrix_r", "get_matrix_int", "get_vector_float64", "sparse_matrix_c", "sparse_matrix_r", ] def accept_matrix_int( arg0: typing.Annotated[ numpy.ndarray, numpy.int32, pybind11_stubgen.typing_ext.FixedSize(3, 3) ], ) -> None: ... def accept_vector_float64( arg0: typing.Annotated[ numpy.ndarray, numpy.float64, pybind11_stubgen.typing_ext.FixedSize(3, 1) ], ) -> None: ... def dense_matrix_c( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", "n") ], ) -> typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", "n") ]: ... def dense_matrix_r( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", "n") ], ) -> typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", "n") ]: ... def fixed_mutator_a( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.FixedSize(5, 6), numpy.ndarray.flags.writeable, ], ) -> None: ... def fixed_mutator_c( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.FixedSize(5, 6), numpy.ndarray.flags.writeable, numpy.ndarray.flags.f_contiguous, ], ) -> None: ... def fixed_mutator_r( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.FixedSize(5, 6), numpy.ndarray.flags.writeable, numpy.ndarray.flags.c_contiguous, ], ) -> None: ... def four_col_matrix_r( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", 4) ], ) -> typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize("m", 4) ]: ... def four_row_matrix_r( arg0: typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize(4, "n") ], ) -> typing.Annotated[ numpy.ndarray, numpy.float32, pybind11_stubgen.typing_ext.DynamicSize(4, "n") ]: ... def get_matrix_int() -> typing.Annotated[ numpy.ndarray, numpy.int32, pybind11_stubgen.typing_ext.FixedSize(3, 3) ]: ... def get_vector_float64() -> typing.Annotated[ numpy.ndarray, numpy.float64, pybind11_stubgen.typing_ext.FixedSize(3, 1) ]: ... def sparse_matrix_c( arg0: typing.Annotated[scipy.sparse.csc_matrix, numpy.float32], ) -> typing.Annotated[scipy.sparse.csc_matrix, numpy.float32]: ... def sparse_matrix_r( arg0: typing.Annotated[scipy.sparse.csr_matrix, numpy.float32], ) -> typing.Annotated[scipy.sparse.csr_matrix, numpy.float32]: ... enum.pyi000066400000000000000000000042501525537303700374420ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "Blue", "ConsoleForegroundColor", "Green", "Magenta", "None_", "Yellow", "accept_defaulted_enum", ] class ConsoleForegroundColor: """ Members: Green Yellow Blue Magenta None_ """ Blue: typing.ClassVar[ ConsoleForegroundColor ] # value = Green: typing.ClassVar[ ConsoleForegroundColor ] # value = Magenta: typing.ClassVar[ ConsoleForegroundColor ] # value = None_: typing.ClassVar[ ConsoleForegroundColor ] # value = Yellow: typing.ClassVar[ ConsoleForegroundColor ] # value = __members__: typing.ClassVar[ dict[str, ConsoleForegroundColor] ] # value = {'Green': , 'Yellow': , 'Blue': , 'Magenta': , 'None_': } def __eq__(self, other: typing.Any) -> bool: ... def __getstate__(self) -> int: ... def __hash__(self) -> int: ... def __index__(self) -> int: ... def __init__(self, value: int) -> None: ... def __int__(self) -> int: ... def __ne__(self, other: typing.Any) -> bool: ... def __repr__(self) -> str: ... def __setstate__(self, state: int) -> None: ... def __str__(self) -> str: ... @property def name(self) -> str: ... @property def value(self) -> int: ... def accept_defaulted_enum( color: ConsoleForegroundColor = ConsoleForegroundColor.None_, ) -> None: ... Blue: ConsoleForegroundColor # value = Green: ConsoleForegroundColor # value = Magenta: ConsoleForegroundColor # value = None_: ConsoleForegroundColor # value = Yellow: ConsoleForegroundColor # value = flawed_bindings.pyi000066400000000000000000000010521525537303700416120ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations __all__: list[str] = [ "Enum", "Unbound", "accept_unbound_enum", "accept_unbound_enum_defaulted", "accept_unbound_type", "accept_unbound_type_defaulted", "get_unbound_type", ] class Unbound: pass class Enum: pass def accept_unbound_enum(arg0: ...) -> int: ... def accept_unbound_enum_defaulted(x: Enum = ...) -> int: ... def accept_unbound_type(arg0: tuple[..., int]) -> int: ... def accept_unbound_type_defaulted(x: Unbound = ...) -> int: ... def get_unbound_type() -> ...: ... functions.pyi000066400000000000000000000041161525537303700405070ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "Foo", "accept_callable", "accept_py_handle", "accept_py_object", "accept_set", "add", "default_custom_arg", "default_int_arg", "default_list_arg", "default_optional_arg", "func_w_anon_args", "func_w_named_pos_args", "generic", "mul", "nested_types", "pass_callback", "passthrough1", "passthrough2", "passthrough3", "passthrough_backwards", "pos_kw_only_mix", "pos_kw_only_variadic_mix", ] class Foo: def __init__(self, arg0: int) -> None: ... def accept_callable(arg0: typing.Callable) -> typing.Any: ... def accept_py_handle(arg0: typing.Any) -> str: ... def accept_py_object(arg0: typing.Any) -> str: ... def accept_set(arg0: set) -> None: ... def add(arg0: int, arg1: int) -> int: ... def default_custom_arg(foo: Foo = Foo(5)) -> None: ... def default_int_arg(n: int = 5) -> None: ... def default_list_arg(l: list = [1, 2, 6, 18]) -> None: ... def default_optional_arg(n: int | None = None) -> None: ... def func_w_anon_args(arg0: int, arg1: int, arg2: int) -> None: ... def func_w_named_pos_args(x: int, y: int, z: int) -> None: ... def generic(*args, **kwargs) -> None: ... @typing.overload def mul(x: int, y: int) -> int: """ Multiply x and y (int) """ @typing.overload def mul(p: float, q: float) -> float: """ Multiply p and q (double) """ def nested_types(arg0: list[Foo] | Foo) -> list[Foo] | Foo: ... def pass_callback(arg0: typing.Callable[[Foo], Foo]) -> Foo: ... def passthrough1[T](obj: T) -> T: ... @typing.overload def passthrough2() -> None: ... @typing.overload def passthrough2[T](obj: T) -> T: ... @typing.overload def passthrough3() -> tuple[None, None]: ... @typing.overload def passthrough3[T](obj: T) -> tuple[T, None]: ... @typing.overload def passthrough3[T1, T2](obj1: T1, obj2: T2) -> tuple[T1, T2]: ... def passthrough_backwards[T](obj: T) -> T: ... def pos_kw_only_mix(i: int, /, j: int, *, k: int) -> tuple: ... def pos_kw_only_variadic_mix(i: int, /, j: int, *args, k: int, **kwargs) -> tuple: ... hidden_builtins.pyi000066400000000000000000000002571525537303700416450ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import types __all__: list[str] = ["mapping_proxy", "none"] mapping_proxy: types.MappingProxyType # value = mappingproxy({}) none = None issues.pyi000066400000000000000000000021111525537303700400030ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "backslashes_should_be_escaped", "issue_51_catastrophic_regex", "issue_73_utf8_doc_chars", "issue_274_docstring_leading_newline", ] def backslashes_should_be_escaped() -> None: """ \\brief A brief description of this function. A detailed description of this function. Here's some reStructuredText: :math:`x = [x, y, \\theta]^T` """ def issue_274_docstring_leading_newline() -> None: """ This is a docstring """ def issue_51_catastrophic_regex(arg0: int, arg1: int) -> None: """ Use-case: issue_51(os.get_handle_inheritable, os.set_handle_inheritable) """ def issue_73_utf8_doc_chars() -> None: """ Construct a Ramsete unicycle controller. Tuning parameter (b > 0 rad²/m²) for which larger values make convergence more aggressive like a proportional term. Tuning parameter (0 rad⁻¹ < zeta < 1 rad⁻¹) for which larger values provide more damping in response. """ _cleanup: typing.Any # value = methods.pyi000066400000000000000000000003041525537303700401350ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations __all__: list[str] = ["Dummy"] class Dummy: @staticmethod def static_method(arg0: int) -> int: ... def regular_method(self, arg0: int) -> int: ... numpy.pyi000066400000000000000000000011451525537303700376460ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing import numpy __all__: list[str] = [ "accept_ndarray_float64", "accept_ndarray_int", "get_ndarray_float64", "get_ndarray_int", "return_dtype", ] def accept_ndarray_float64( arg0: typing.Annotated[numpy.ndarray, numpy.float64], ) -> None: ... def accept_ndarray_int(arg0: typing.Annotated[numpy.ndarray, numpy.int32]) -> None: ... def get_ndarray_float64() -> typing.Annotated[numpy.ndarray, numpy.float64]: ... def get_ndarray_int() -> typing.Annotated[numpy.ndarray, numpy.int32]: ... def return_dtype() -> numpy.dtype[typing.Any]: ... properties.pyi000066400000000000000000000045431525537303700406770ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "WithGetterSetterDoc", "WithPropAndGetterSetterDoc", "WithPropDoc", "WithoutDoc", ] class WithoutDoc: """ No user docstring provided """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 def_property: int def_readwrite: int @property def def_property_readonly(self) -> int: ... @property def def_readonly(self) -> int: ... class WithPropDoc: """ User docstring provided only to `def_` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 @property def def_property(self) -> int: """ prop doc token """ @def_property.setter def def_property(self, arg1: int) -> None: ... @property def def_property_readonly(self) -> int: """ prop doc token """ @property def def_readonly(self) -> int: """ prop doc token """ @property def def_readwrite(self) -> int: """ prop doc token """ @def_readwrite.setter def def_readwrite(self, arg0: int) -> None: ... class WithGetterSetterDoc: """ User docstring provided via pybind11::cpp_function(..., doc) to getters/setters, but NOT to `def_*(..., doc)` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 @property def def_property(self) -> int: """ getter doc token """ @def_property.setter def def_property(self, arg1: int) -> None: """ setter doc token """ @property def def_property_readonly(self) -> int: """ getter doc token """ class WithPropAndGetterSetterDoc: """ User docstring provided via pybind11::cpp_function(..., doc) to getters/setters and to `def_*(, doc)` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 @property def def_property(self) -> int: """ prop doc token """ @def_property.setter def def_property(self, arg1: int) -> None: ... @property def def_property_readonly(self) -> int: """ prop doc token """ stl.pyi000066400000000000000000000006511525537303700373010ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "std_array", "std_map", "std_optional", "std_variant", "std_vector", ] def std_array(arg0: list[int[3]]) -> list[int[3]]: ... def std_map() -> dict[int, complex]: ... def std_optional(arg0: int | None) -> None: ... def std_variant(arg0: int | float | tuple[int, int]) -> None: ... def std_vector() -> list[tuple[int, float]]: ... stl_bind.pyi000066400000000000000000000076051525537303700403030ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "MapStringComplex", "VectorPairStringDouble", "get_complex_map", "get_vector_of_pairs", ] class VectorPairStringDouble: __hash__: typing.ClassVar[None] = None def __bool__(self) -> bool: """ Check whether the list is nonempty """ def __contains__(self, x: tuple[str, float]) -> bool: """ Return true the container contains ``x`` """ @typing.overload def __delitem__(self, arg0: int) -> None: """ Delete the list elements at index ``i`` """ @typing.overload def __delitem__(self, arg0: slice) -> None: """ Delete list elements using a slice object """ def __eq__(self, arg0: VectorPairStringDouble) -> bool: ... @typing.overload def __getitem__(self, s: slice) -> VectorPairStringDouble: """ Retrieve list elements using a slice object """ @typing.overload def __getitem__(self, arg0: int) -> tuple[str, float]: ... @typing.overload def __init__(self) -> None: ... @typing.overload def __init__(self, arg0: VectorPairStringDouble) -> None: """ Copy constructor """ @typing.overload def __init__(self, arg0: typing.Iterable) -> None: ... def __iter__(self) -> typing.Iterator: ... def __len__(self) -> int: ... def __ne__(self, arg0: VectorPairStringDouble) -> bool: ... @typing.overload def __setitem__(self, arg0: int, arg1: tuple[str, float]) -> None: ... @typing.overload def __setitem__(self, arg0: slice, arg1: VectorPairStringDouble) -> None: """ Assign list elements using a slice object """ def append(self, x: tuple[str, float]) -> None: """ Add an item to the end of the list """ def clear(self) -> None: """ Clear the contents """ def count(self, x: tuple[str, float]) -> int: """ Return the number of times ``x`` appears in the list """ @typing.overload def extend(self, L: VectorPairStringDouble) -> None: """ Extend the list by appending all the items in the given list """ @typing.overload def extend(self, L: typing.Iterable) -> None: """ Extend the list by appending all the items in the given list """ def insert(self, i: int, x: tuple[str, float]) -> None: """ Insert an item at a given position. """ @typing.overload def pop(self) -> tuple[str, float]: """ Remove and return the last item """ @typing.overload def pop(self, i: int) -> tuple[str, float]: """ Remove and return the item at index ``i`` """ def remove(self, x: tuple[str, float]) -> None: """ Remove the first item from the list whose value is x. It is an error if there is no such item. """ class MapStringComplex: def __bool__(self) -> bool: """ Check whether the map is nonempty """ @typing.overload def __contains__(self, arg0: str) -> bool: ... @typing.overload def __contains__(self, arg0: typing.Any) -> bool: ... def __delitem__(self, arg0: str) -> None: ... def __getitem__(self, arg0: str) -> complex: ... def __init__(self) -> None: ... def __iter__(self) -> typing.Iterator: ... def __len__(self) -> int: ... def __repr__(self) -> str: """ Return the canonical string representation of this map. """ def __setitem__(self, arg0: str, arg1: complex) -> None: ... def items(self) -> typing.ItemsView[MapStringComplex]: ... def keys(self) -> typing.KeysView[MapStringComplex]: ... def values(self) -> typing.ValuesView[MapStringComplex]: ... def get_complex_map() -> MapStringComplex: ... def get_vector_of_pairs() -> VectorPairStringDouble: ... typing.pyi000066400000000000000000000004221525537303700400050ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing import typing_extensions __all__: list[str] = ["get_buffer", "get_sequence"] def get_buffer(arg0: typing_extensions.Buffer) -> typing_extensions.Buffer: ... def get_sequence(arg0: typing.Sequence) -> typing.Sequence: ... values.pyi000066400000000000000000000014521525537303700377760ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import datetime import numpy from numpy import random __all__: list[str] = [ "Dummy", "Foo", "add_day", "foolist", "foovar", "list_with_none", "none", "random", "t_10ms", "t_20ns", "t_30s", ] class Dummy: linalg = numpy.linalg class Foo: pass def add_day(arg0: datetime.datetime) -> datetime.datetime: ... foolist: list # value = [, ] foovar: Foo # value = list_with_none: list = [None, 2, {}] none = None t_10ms: datetime.timedelta # value = datetime.timedelta(microseconds=10000) t_20ns: datetime.timedelta # value = datetime.timedelta(0) t_30s: datetime.timedelta # value = datetime.timedelta(seconds=30) core.pyi000066400000000000000000000010211525537303700354630ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9/numpy-array-wrap-with-annotated/demofrom __future__ import annotations from demo._bindings import ( aliases, classes, eigen, enum, flawed_bindings, functions, hidden_builtins, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) __all__: list[str] = [ "aliases", "classes", "eigen", "enum", "flawed_bindings", "functions", "hidden_builtins", "issues", "methods", "numpy", "properties", "stl", "stl_bind", "typing", "values", ] pure_python/000077500000000000000000000000001525537303700363725ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9/numpy-array-wrap-with-annotated/demo__init__.pyi000066400000000000000000000003611525537303700406540ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations from . import classes, functions, functions_3_8_plus, functions_3_9_plus, values __all__: list[str] = [ "classes", "functions", "functions_3_8_plus", "functions_3_9_plus", "values", ] classes.pyi000066400000000000000000000003071525537303700405520ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["A", "B", "C", "X"] class A: """ A """ class B(A): """ B """ class C(B): """ C """ class X: pass functions.pyi000066400000000000000000000015561525537303700411340ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations import sys as sys import typing as typing from demo.pure_python.functions_3_8_plus import args_mix from demo.pure_python.functions_3_9_plus import generic_alias_annotation __all__: list[str] = [ "accept_frozenset", "args_mix", "builtin_function_as_default_arg", "function_as_default_arg", "generic_alias_annotation", "lambda_as_default_arg", "search", "static_method_as_default_arg", "sys", "typing", ] class _Dummy: @staticmethod def foo(): ... def accept_frozenset(arg: frozenset[int | float]) -> int | None: ... def builtin_function_as_default_arg(func: type(len) = len): ... def function_as_default_arg(func: type(search) = search): ... def lambda_as_default_arg(callback=...): ... def search(a: int, b: list[int]) -> int: ... def static_method_as_default_arg(callback=_Dummy.foo): ... functions_3_8_plus.pyi000066400000000000000000000007761525537303700426530ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations import typing as typing __all__: list[str] = [ "Expression", "Token", "args_mix", "nested_current_module_annotations", "typing", ] class Token: pass class Expression: pass def args_mix( a: int, b: float = 0.5, c: str = "", *args: int, x: int = 1, y=int, **kwargs: dict[int, str], ): ... def nested_current_module_annotations( tokens: list[Token], expr: Expression | None = None ) -> dict[str, Expression]: ... functions_3_9_plus.pyi000066400000000000000000000002601525537303700426400ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["generic_alias_annotation"] def generic_alias_annotation(a: list[tuple[int]], b: dict[int, str]) -> list[float]: ... values.pyi000066400000000000000000000001741525537303700404160ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v2.9/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["callables_dict"] callables_dict: dict = {"len": len, "int": int} pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/000077500000000000000000000000001525537303700247625ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-use-type-var/000077500000000000000000000000001525537303700316055ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-use-type-var/demo/000077500000000000000000000000001525537303700325315ustar00rootroot00000000000000__init__.pyi000066400000000000000000000012021525537303700347270ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-use-type-var/demofrom __future__ import annotations from demo._bindings import ( aliases, classes, eigen, enum, flawed_bindings, functions, hidden_builtins, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) from . import _bindings, core, pure_python __all__: list[str] = [ "aliases", "classes", "core", "eigen", "enum", "flawed_bindings", "functions", "hidden_builtins", "issues", "methods", "numpy", "properties", "pure_python", "stl", "stl_bind", "typing", "values", "version", ] version: str = "0.0.0" _bindings/000077500000000000000000000000001525537303700344065ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-use-type-var/demo__init__.pyi000066400000000000000000000010041525537303700366630ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations from . import ( aliases, classes, eigen, enum, flawed_bindings, functions, hidden_builtins, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) __all__: list[str] = [ "aliases", "classes", "eigen", "enum", "flawed_bindings", "functions", "hidden_builtins", "issues", "methods", "numpy", "properties", "stl", "stl_bind", "typing", "values", ] aliases/000077500000000000000000000000001525537303700360275ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-use-type-var/demo/_bindings__init__.pyi000066400000000000000000000021441525537303700403120ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-use-type-var/demo/_bindings/aliasesfrom __future__ import annotations import typing import demo._bindings.enum import numpy from demo._bindings.aliases.foreign_method_arg import Bar2 as foreign_type_alias from demo._bindings.aliases.foreign_return import get_foo as foreign_class_alias from numpy import random from . import ( foreign_arg, foreign_attr, foreign_class_member, foreign_method_arg, foreign_method_return, foreign_return, missing_self_arg, ) __all__: list[str] = [ "Color", "Dummy", "foreign_arg", "foreign_attr", "foreign_class_alias", "foreign_class_member", "foreign_enum_default", "foreign_method_arg", "foreign_method_return", "foreign_return", "foreign_type_alias", "func", "local_func_alias", "local_type_alias", "missing_self_arg", "random", ] class Dummy: linalg = numpy.linalg class Color: pass def foreign_enum_default( color: typing.Any = demo._bindings.enum.ConsoleForegroundColor.Blue, ) -> None: ... def func(arg0: typing.SupportsInt | typing.SupportsIndex) -> int: ... local_type_alias = Color local_func_alias = func foreign_arg.pyi000066400000000000000000000002371525537303700410360ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-use-type-var/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["set_foo"] def set_foo(arg0: demo._bindings.classes.Foo) -> int: ... foreign_attr.pyi000066400000000000000000000002631525537303700412360ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-use-type-var/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["value"] value: demo._bindings.classes.Foo # value = foreign_class_member.pyi000066400000000000000000000003571525537303700427240ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-use-type-var/demo/_bindings/aliasesfrom __future__ import annotations import typing import demo._bindings.classes __all__: list[str] = ["Bar1"] class Bar1: foo: typing.ClassVar[ demo._bindings.classes.Foo ] # value = foreign_method_arg.pyi000066400000000000000000000002621525537303700423740ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-use-type-var/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar2"] class Bar2: def set_foo(self, arg0: demo._bindings.classes.Foo) -> int: ... foreign_method_return.pyi000066400000000000000000000002651525537303700431450ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-use-type-var/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar3"] class Bar3: @staticmethod def get_foo() -> demo._bindings.classes.Foo: ... foreign_return.pyi000066400000000000000000000002261525537303700416020ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-use-type-var/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["get_foo"] def get_foo() -> demo._bindings.classes.Foo: ... missing_self_arg.pyi000066400000000000000000000002541525537303700420660ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-use-type-var/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar4"] class Bar4: def set_foo(self: demo._bindings.classes.Foo) -> int: ... classes.pyi000066400000000000000000000046021525537303700365700ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "CppException", "Derived", "Foo", "MyBase", "Outer", "ParIter", "ParIterBase", "ParticleContainer", ] class Outer: class Inner: class NestedEnum: """ Members: ONE TWO """ ONE: typing.ClassVar[Outer.Inner.NestedEnum] # value = TWO: typing.ClassVar[Outer.Inner.NestedEnum] # value = __members__: typing.ClassVar[ dict[str, Outer.Inner.NestedEnum] ] # value = {'ONE': , 'TWO': } def __eq__(self, other: typing.Any) -> bool: ... def __getstate__(self) -> int: ... def __hash__(self) -> int: ... def __index__(self) -> int: ... def __init__( self, value: typing.SupportsInt | typing.SupportsIndex ) -> None: ... def __int__(self) -> int: ... def __ne__(self, other: typing.Any) -> bool: ... def __repr__(self) -> str: ... def __setstate__( self, state: typing.SupportsInt | typing.SupportsIndex ) -> None: ... def __str__(self) -> str: ... @property def name(self) -> str: ... @property def value(self) -> int: ... value: Outer.Inner.NestedEnum inner: Outer.Inner class MyBase: class Inner: pass name: str class Derived(MyBase): @property def count(self) -> int: ... @count.setter def count(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None: ... class Foo: class FooChild: def __init__(self) -> None: ... def g(self) -> None: ... def __init__(self) -> None: ... def f(self) -> None: ... class ParIterBase: @property def level(self) -> int: ... @level.setter def level(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None: ... class ParIter(ParIterBase): def __init__( self, particle_container: ParticleContainer, level: typing.SupportsInt | typing.SupportsIndex, ) -> None: ... class ParticleContainer: name: str Iterator = ParIter def process(self, arg0: ParIter) -> None: ... class CppException(Exception): pass eigen.pyi000066400000000000000000000043201525537303700362170ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import typing import numpy import numpy.typing import scipy.sparse __all__: list[str] = [ "accept_matrix_int", "accept_vector_float64", "dense_matrix_c", "dense_matrix_r", "fixed_mutator_a", "fixed_mutator_c", "fixed_mutator_r", "four_col_matrix_r", "four_row_matrix_r", "get_matrix_int", "get_vector_float64", "sparse_matrix_c", "sparse_matrix_r", ] def accept_matrix_int( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.int32, "[3, 3]"], ) -> None: ... def accept_vector_float64( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, "[3, 1]"], ) -> None: ... def dense_matrix_c( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.float32, "[m, n]"], ) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[m, n]"]: ... def dense_matrix_r( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.float32, "[m, n]"], ) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[m, n]"]: ... def fixed_mutator_a( arg0: typing.Annotated[ numpy.typing.NDArray[numpy.float32], "[5, 6]", "flags.writeable" ], ) -> None: ... def fixed_mutator_c( arg0: typing.Annotated[ numpy.typing.NDArray[numpy.float32], "[5, 6]", "flags.writeable", "flags.f_contiguous", ], ) -> None: ... def fixed_mutator_r( arg0: typing.Annotated[ numpy.typing.NDArray[numpy.float32], "[5, 6]", "flags.writeable", "flags.c_contiguous", ], ) -> None: ... def four_col_matrix_r( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.float32, "[m, 4]"], ) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[m, 4]"]: ... def four_row_matrix_r( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.float32, "[4, n]"], ) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, n]"]: ... def get_matrix_int() -> typing.Annotated[ numpy.typing.NDArray[numpy.int32], "[3, 3]" ]: ... def get_vector_float64() -> typing.Annotated[ numpy.typing.NDArray[numpy.float64], "[3, 1]" ]: ... def sparse_matrix_c(arg0: scipy.sparse.csc_matrix) -> scipy.sparse.csc_matrix: ... def sparse_matrix_r(arg0: scipy.sparse.csr_matrix) -> scipy.sparse.csr_matrix: ... enum.pyi000066400000000000000000000051701525537303700361000ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import enum import typing __all__: list[str] = [ "Blue", "ConsoleForegroundColor", "Green", "Magenta", "NativeColor", "None_", "Yellow", "accept_defaulted_enum", ] class ConsoleForegroundColor: """ Members: Green Yellow Blue Magenta None_ """ Blue: typing.ClassVar[ ConsoleForegroundColor ] # value = Green: typing.ClassVar[ ConsoleForegroundColor ] # value = Magenta: typing.ClassVar[ ConsoleForegroundColor ] # value = None_: typing.ClassVar[ ConsoleForegroundColor ] # value = Yellow: typing.ClassVar[ ConsoleForegroundColor ] # value = __members__: typing.ClassVar[ dict[str, ConsoleForegroundColor] ] # value = {'Green': , 'Yellow': , 'Blue': , 'Magenta': , 'None_': } def __eq__(self, other: typing.Any) -> bool: ... def __getstate__(self) -> int: ... def __hash__(self) -> int: ... def __index__(self) -> int: ... def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None: ... def __int__(self) -> int: ... def __ne__(self, other: typing.Any) -> bool: ... def __repr__(self) -> str: ... def __setstate__( self, state: typing.SupportsInt | typing.SupportsIndex ) -> None: ... def __str__(self) -> str: ... @property def name(self) -> str: ... @property def value(self) -> int: ... class NativeColor(enum.IntEnum): Blue: typing.ClassVar[NativeColor] # value = Red: typing.ClassVar[NativeColor] # value = @classmethod def __new__(cls, value): ... def __format__(self, format_spec): """ Convert to a string according to format_spec. """ def accept_defaulted_enum( color: ConsoleForegroundColor = ConsoleForegroundColor.None_, ) -> None: ... Blue: ConsoleForegroundColor # value = Green: ConsoleForegroundColor # value = Magenta: ConsoleForegroundColor # value = None_: ConsoleForegroundColor # value = Yellow: ConsoleForegroundColor # value = flawed_bindings.pyi000066400000000000000000000011461525537303700402520ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "Enum", "Unbound", "accept_unbound_enum", "accept_unbound_enum_defaulted", "accept_unbound_type", "accept_unbound_type_defaulted", "get_unbound_type", ] class Unbound: pass class Enum: pass def accept_unbound_enum(arg0: ...) -> int: ... def accept_unbound_enum_defaulted(x: Enum = ...) -> int: ... def accept_unbound_type( arg0: tuple[..., typing.SupportsInt | typing.SupportsIndex], ) -> int: ... def accept_unbound_type_defaulted(x: Unbound = ...) -> int: ... def get_unbound_type() -> ...: ... functions.pyi000066400000000000000000000066321525537303700371500ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import collections.abc import typing __all__: list[str] = [ "Foo", "accept_annotated_callable", "accept_callable", "accept_frozenset", "accept_py_handle", "accept_py_object", "accept_set", "add", "default_custom_arg", "default_int_arg", "default_list_arg", "default_optional_arg", "func_w_anon_args", "func_w_named_pos_args", "generic", "mul", "nested_types", "pass_callback", "passthrough1", "passthrough2", "passthrough3", "passthrough_backwards", "pos_kw_only_mix", "pos_kw_only_variadic_mix", ] class Foo: def __init__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None: ... def accept_annotated_callable( arg0: collections.abc.Callable[ [ typing.SupportsInt | typing.SupportsIndex, typing.SupportsInt | typing.SupportsIndex, ], int, ], ) -> typing.Any: ... def accept_callable(arg0: collections.abc.Callable) -> typing.Any: ... def accept_frozenset(arg0: frozenset) -> None: ... def accept_py_handle(arg0: typing.Any) -> str: ... def accept_py_object(arg0: typing.Any) -> str: ... def accept_set(arg0: set) -> None: ... def add( arg0: typing.SupportsInt | typing.SupportsIndex, arg1: typing.SupportsInt | typing.SupportsIndex, ) -> int: ... def default_custom_arg(foo: Foo = Foo(5)) -> None: ... def default_int_arg(n: typing.SupportsInt | typing.SupportsIndex = 5) -> None: ... def default_list_arg(l: list = [1, 2, 6, 18]) -> None: ... def default_optional_arg( n: typing.SupportsInt | typing.SupportsIndex | None = None, ) -> None: ... def func_w_anon_args( arg0: typing.SupportsInt | typing.SupportsIndex, arg1: typing.SupportsInt | typing.SupportsIndex, arg2: typing.SupportsInt | typing.SupportsIndex, ) -> None: ... def func_w_named_pos_args( x: typing.SupportsInt | typing.SupportsIndex, y: typing.SupportsInt | typing.SupportsIndex, z: typing.SupportsInt | typing.SupportsIndex, ) -> None: ... def generic(*args, **kwargs) -> None: ... @typing.overload def mul( x: typing.SupportsInt | typing.SupportsIndex, y: typing.SupportsInt | typing.SupportsIndex, ) -> int: """ Multiply x and y (int) """ @typing.overload def mul( p: typing.SupportsFloat | typing.SupportsIndex, q: typing.SupportsFloat | typing.SupportsIndex, ) -> float: """ Multiply p and q (double) """ def nested_types(arg0: collections.abc.Sequence[Foo] | Foo) -> list[Foo] | Foo: ... def pass_callback(arg0: collections.abc.Callable[[Foo], Foo]) -> Foo: ... def passthrough1[T](obj: T) -> T: ... @typing.overload def passthrough2() -> None: ... @typing.overload def passthrough2[T](obj: T) -> T: ... @typing.overload def passthrough3() -> tuple[None, None]: ... @typing.overload def passthrough3[T](obj: T) -> tuple[T, None]: ... @typing.overload def passthrough3[T1, T2](obj1: T1, obj2: T2) -> tuple[T1, T2]: ... def passthrough_backwards[T](obj: T) -> T: ... def pos_kw_only_mix( i: typing.SupportsInt | typing.SupportsIndex, /, j: typing.SupportsInt | typing.SupportsIndex, *, k: typing.SupportsInt | typing.SupportsIndex, ) -> tuple[int, int, int]: ... def pos_kw_only_variadic_mix( i: typing.SupportsInt | typing.SupportsIndex, /, j: typing.SupportsInt | typing.SupportsIndex, *args, k: typing.SupportsInt | typing.SupportsIndex, **kwargs, ) -> tuple[int, int, int]: ... hidden_builtins.pyi000066400000000000000000000002571525537303700403010ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import types __all__: list[str] = ["mapping_proxy", "none"] mapping_proxy: types.MappingProxyType # value = mappingproxy({}) none = None issues.pyi000066400000000000000000000022401525537303700364420ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "backslashes_should_be_escaped", "issue_51_catastrophic_regex", "issue_73_utf8_doc_chars", "issue_274_docstring_leading_newline", ] def backslashes_should_be_escaped() -> None: """ \\brief A brief description of this function. A detailed description of this function. Here's some reStructuredText: :math:`x = [x, y, \\theta]^T` """ def issue_274_docstring_leading_newline() -> None: """ This is a docstring """ def issue_51_catastrophic_regex( arg0: typing.SupportsInt | typing.SupportsIndex, arg1: typing.SupportsInt | typing.SupportsIndex, ) -> None: """ Use-case: issue_51(os.get_handle_inheritable, os.set_handle_inheritable) """ def issue_73_utf8_doc_chars() -> None: """ Construct a Ramsete unicycle controller. Tuning parameter (b > 0 rad²/m²) for which larger values make convergence more aggressive like a proportional term. Tuning parameter (0 rad⁻¹ < zeta < 1 rad⁻¹) for which larger values provide more damping in response. """ _cleanup: typing.Any # value = methods.pyi000066400000000000000000000004551525537303700366000ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = ["Dummy"] class Dummy: @staticmethod def static_method(arg0: typing.SupportsInt | typing.SupportsIndex) -> int: ... def regular_method( self, arg0: typing.SupportsInt | typing.SupportsIndex ) -> int: ... numpy.pyi000066400000000000000000000011741525537303700363040ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import typing import numpy import numpy.typing __all__: list[str] = [ "accept_ndarray_float64", "accept_ndarray_int", "get_ndarray_float64", "get_ndarray_int", "return_dtype", ] def accept_ndarray_float64( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.float64], ) -> None: ... def accept_ndarray_int( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.int32], ) -> None: ... def get_ndarray_float64() -> numpy.typing.NDArray[numpy.float64]: ... def get_ndarray_int() -> numpy.typing.NDArray[numpy.int32]: ... def return_dtype() -> numpy.dtype[typing.Any]: ... properties.pyi000066400000000000000000000060211525537303700373240ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "WithGetterSetterDoc", "WithPropAndGetterSetterDoc", "WithPropDoc", "WithoutDoc", ] class WithoutDoc: """ No user docstring provided """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 @property def def_property(self) -> int: ... @def_property.setter def def_property(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None: ... @property def def_property_readonly(self) -> int: ... @property def def_readonly(self) -> int: ... @property def def_readwrite(self) -> int: ... @def_readwrite.setter def def_readwrite( self, arg0: typing.SupportsInt | typing.SupportsIndex ) -> None: ... class WithPropDoc: """ User docstring provided only to `def_` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 """ prop doc token """ def_property_static: typing.ClassVar[int] = 0 """ prop doc token """ @property def def_property(self) -> int: """ prop doc token """ @def_property.setter def def_property(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None: ... @property def def_property_readonly(self) -> int: """ prop doc token """ @property def def_readonly(self) -> int: """ prop doc token """ @property def def_readwrite(self) -> int: """ prop doc token """ @def_readwrite.setter def def_readwrite( self, arg0: typing.SupportsInt | typing.SupportsIndex ) -> None: ... class WithGetterSetterDoc: """ User docstring provided via pybind11::cpp_function(..., doc) to getters/setters, but NOT to `def_*(..., doc)` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 """ getter doc token """ def_property_static: typing.ClassVar[int] = 0 """ getter doc token """ @property def def_property(self) -> int: """ getter doc token """ @def_property.setter def def_property(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None: """ setter doc token """ @property def def_property_readonly(self) -> int: """ getter doc token """ class WithPropAndGetterSetterDoc: """ User docstring provided via pybind11::cpp_function(..., doc) to getters/setters and to `def_*(, doc)` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 """ prop doc token """ def_property_static: typing.ClassVar[int] = 0 """ prop doc token """ @property def def_property(self) -> int: """ prop doc token """ @def_property.setter def def_property(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None: ... @property def def_property_readonly(self) -> int: """ prop doc token """ stl.pyi000066400000000000000000000015021525537303700357310ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import collections.abc import typing __all__: list[str] = [ "std_array", "std_map", "std_optional", "std_variant", "std_vector", ] def std_array( arg0: typing.Annotated[ collections.abc.Sequence[typing.SupportsInt | typing.SupportsIndex], "FixedSize(3)", ], ) -> typing.Annotated[list[int], "FixedSize(3)"]: ... def std_map() -> dict[int, complex]: ... def std_optional(arg0: typing.SupportsInt | typing.SupportsIndex | None) -> None: ... def std_variant( arg0: typing.SupportsInt | typing.SupportsIndex | typing.SupportsFloat | typing.SupportsIndex | tuple[ typing.SupportsInt | typing.SupportsIndex, typing.SupportsInt | typing.SupportsIndex, ], ) -> None: ... def std_vector() -> list[tuple[int, float]]: ... stl_bind.pyi000066400000000000000000000110261525537303700367270ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import collections.abc import typing __all__: list[str] = [ "MapStringComplex", "VectorPairStringDouble", "get_complex_map", "get_vector_of_pairs", ] class VectorPairStringDouble: __hash__: typing.ClassVar[None] = None def __bool__(self) -> bool: """ Check whether the list is nonempty """ def __contains__( self, x: tuple[str, typing.SupportsFloat | typing.SupportsIndex] ) -> bool: """ Return true the container contains ``x`` """ @typing.overload def __delitem__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None: """ Delete the list elements at index ``i`` """ @typing.overload def __delitem__(self, arg0: slice) -> None: """ Delete list elements using a slice object """ def __eq__(self, arg0: VectorPairStringDouble) -> bool: ... @typing.overload def __getitem__(self, s: slice) -> VectorPairStringDouble: """ Retrieve list elements using a slice object """ @typing.overload def __getitem__( self, arg0: typing.SupportsInt | typing.SupportsIndex ) -> tuple[str, float]: ... @typing.overload def __init__(self) -> None: ... @typing.overload def __init__(self, arg0: VectorPairStringDouble) -> None: """ Copy constructor """ @typing.overload def __init__(self, arg0: collections.abc.Iterable) -> None: ... def __iter__(self) -> collections.abc.Iterator[tuple[str, float]]: ... def __len__(self) -> int: ... def __ne__(self, arg0: VectorPairStringDouble) -> bool: ... @typing.overload def __setitem__( self, arg0: typing.SupportsInt | typing.SupportsIndex, arg1: tuple[str, typing.SupportsFloat | typing.SupportsIndex], ) -> None: ... @typing.overload def __setitem__(self, arg0: slice, arg1: VectorPairStringDouble) -> None: """ Assign list elements using a slice object """ def append( self, x: tuple[str, typing.SupportsFloat | typing.SupportsIndex] ) -> None: """ Add an item to the end of the list """ def clear(self) -> None: """ Clear the contents """ def count(self, x: tuple[str, typing.SupportsFloat | typing.SupportsIndex]) -> int: """ Return the number of times ``x`` appears in the list """ @typing.overload def extend(self, L: VectorPairStringDouble) -> None: """ Extend the list by appending all the items in the given list """ @typing.overload def extend(self, L: collections.abc.Iterable) -> None: """ Extend the list by appending all the items in the given list """ def insert( self, i: typing.SupportsInt | typing.SupportsIndex, x: tuple[str, typing.SupportsFloat | typing.SupportsIndex], ) -> None: """ Insert an item at a given position. """ @typing.overload def pop(self) -> tuple[str, float]: """ Remove and return the last item """ @typing.overload def pop(self, i: typing.SupportsInt | typing.SupportsIndex) -> tuple[str, float]: """ Remove and return the item at index ``i`` """ def remove( self, x: tuple[str, typing.SupportsFloat | typing.SupportsIndex] ) -> None: """ Remove the first item from the list whose value is x. It is an error if there is no such item. """ class MapStringComplex: def __bool__(self) -> bool: """ Check whether the map is nonempty """ @typing.overload def __contains__(self, arg0: str) -> bool: ... @typing.overload def __contains__(self, arg0: typing.Any) -> bool: ... def __delitem__(self, arg0: str) -> None: ... def __getitem__(self, arg0: str) -> complex: ... def __init__(self) -> None: ... def __iter__(self) -> collections.abc.Iterator[str]: ... def __len__(self) -> int: ... def __repr__(self) -> str: """ Return the canonical string representation of this map. """ def __setitem__( self, arg0: str, arg1: typing.SupportsComplex | typing.SupportsFloat | typing.SupportsIndex, ) -> None: ... def items(self) -> typing.ItemsView: ... def keys(self) -> typing.KeysView: ... def values(self) -> typing.ValuesView: ... def get_complex_map() -> MapStringComplex: ... def get_vector_of_pairs() -> VectorPairStringDouble: ... typing.pyi000066400000000000000000000004171525537303700364450ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import collections.abc __all__: list[str] = ["get_buffer", "get_sequence"] def get_buffer(arg0: collections.abc.Buffer) -> collections.abc.Buffer: ... def get_sequence(arg0: collections.abc.Sequence) -> collections.abc.Sequence: ... values.pyi000066400000000000000000000014521525537303700364320ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-use-type-var/demo/_bindingsfrom __future__ import annotations import datetime import numpy from numpy import random __all__: list[str] = [ "Dummy", "Foo", "add_day", "foolist", "foovar", "list_with_none", "none", "random", "t_10ms", "t_20ns", "t_30s", ] class Dummy: linalg = numpy.linalg class Foo: pass def add_day(arg0: datetime.datetime) -> datetime.datetime: ... foolist: list # value = [, ] foovar: Foo # value = list_with_none: list = [None, 2, {}] none = None t_10ms: datetime.timedelta # value = datetime.timedelta(microseconds=10000) t_20ns: datetime.timedelta # value = datetime.timedelta(0) t_30s: datetime.timedelta # value = datetime.timedelta(seconds=30) core.pyi000066400000000000000000000010211525537303700341170ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-use-type-var/demofrom __future__ import annotations from demo._bindings import ( aliases, classes, eigen, enum, flawed_bindings, functions, hidden_builtins, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) __all__: list[str] = [ "aliases", "classes", "eigen", "enum", "flawed_bindings", "functions", "hidden_builtins", "issues", "methods", "numpy", "properties", "stl", "stl_bind", "typing", "values", ] pure_python/000077500000000000000000000000001525537303700350265ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-use-type-var/demo__init__.pyi000066400000000000000000000003611525537303700373100ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-use-type-var/demo/pure_pythonfrom __future__ import annotations from . import classes, functions, functions_3_8_plus, functions_3_9_plus, values __all__: list[str] = [ "classes", "functions", "functions_3_8_plus", "functions_3_9_plus", "values", ] classes.pyi000066400000000000000000000003071525537303700372060ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-use-type-var/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["A", "B", "C", "X"] class A: """ A """ class B(A): """ B """ class C(B): """ C """ class X: pass functions.pyi000066400000000000000000000015561525537303700375700ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-use-type-var/demo/pure_pythonfrom __future__ import annotations import sys as sys import typing as typing from demo.pure_python.functions_3_8_plus import args_mix from demo.pure_python.functions_3_9_plus import generic_alias_annotation __all__: list[str] = [ "accept_frozenset", "args_mix", "builtin_function_as_default_arg", "function_as_default_arg", "generic_alias_annotation", "lambda_as_default_arg", "search", "static_method_as_default_arg", "sys", "typing", ] class _Dummy: @staticmethod def foo(): ... def accept_frozenset(arg: frozenset[int | float]) -> int | None: ... def builtin_function_as_default_arg(func: type(len) = len): ... def function_as_default_arg(func: type(search) = search): ... def lambda_as_default_arg(callback=...): ... def search(a: int, b: list[int]) -> int: ... def static_method_as_default_arg(callback=_Dummy.foo): ... functions_3_8_plus.pyi000066400000000000000000000007761525537303700413070ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-use-type-var/demo/pure_pythonfrom __future__ import annotations import typing as typing __all__: list[str] = [ "Expression", "Token", "args_mix", "nested_current_module_annotations", "typing", ] class Token: pass class Expression: pass def args_mix( a: int, b: float = 0.5, c: str = "", *args: int, x: int = 1, y=int, **kwargs: dict[int, str], ): ... def nested_current_module_annotations( tokens: list[Token], expr: Expression | None = None ) -> dict[str, Expression]: ... functions_3_9_plus.pyi000066400000000000000000000002601525537303700412740ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-use-type-var/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["generic_alias_annotation"] def generic_alias_annotation(a: list[tuple[int]], b: dict[int, str]) -> list[float]: ... values.pyi000066400000000000000000000001741525537303700370520ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-use-type-var/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["callables_dict"] callables_dict: dict = {"len": len, "int": int} numpy-array-wrap-with-annotated/000077500000000000000000000000001525537303700330625ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0demo/000077500000000000000000000000001525537303700340065ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-wrap-with-annotated__init__.pyi000066400000000000000000000012021525537303700362630ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-wrap-with-annotated/demofrom __future__ import annotations from demo._bindings import ( aliases, classes, eigen, enum, flawed_bindings, functions, hidden_builtins, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) from . import _bindings, core, pure_python __all__: list[str] = [ "aliases", "classes", "core", "eigen", "enum", "flawed_bindings", "functions", "hidden_builtins", "issues", "methods", "numpy", "properties", "pure_python", "stl", "stl_bind", "typing", "values", "version", ] version: str = "0.0.0" _bindings/000077500000000000000000000000001525537303700357425ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-wrap-with-annotated/demo__init__.pyi000066400000000000000000000010041525537303700402170ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations from . import ( aliases, classes, eigen, enum, flawed_bindings, functions, hidden_builtins, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) __all__: list[str] = [ "aliases", "classes", "eigen", "enum", "flawed_bindings", "functions", "hidden_builtins", "issues", "methods", "numpy", "properties", "stl", "stl_bind", "typing", "values", ] aliases/000077500000000000000000000000001525537303700373635ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindings__init__.pyi000066400000000000000000000021441525537303700416460ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import typing import demo._bindings.enum import numpy from demo._bindings.aliases.foreign_method_arg import Bar2 as foreign_type_alias from demo._bindings.aliases.foreign_return import get_foo as foreign_class_alias from numpy import random from . import ( foreign_arg, foreign_attr, foreign_class_member, foreign_method_arg, foreign_method_return, foreign_return, missing_self_arg, ) __all__: list[str] = [ "Color", "Dummy", "foreign_arg", "foreign_attr", "foreign_class_alias", "foreign_class_member", "foreign_enum_default", "foreign_method_arg", "foreign_method_return", "foreign_return", "foreign_type_alias", "func", "local_func_alias", "local_type_alias", "missing_self_arg", "random", ] class Dummy: linalg = numpy.linalg class Color: pass def foreign_enum_default( color: typing.Any = demo._bindings.enum.ConsoleForegroundColor.Blue, ) -> None: ... def func(arg0: typing.SupportsInt | typing.SupportsIndex) -> int: ... local_type_alias = Color local_func_alias = func foreign_arg.pyi000066400000000000000000000002371525537303700423720ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["set_foo"] def set_foo(arg0: demo._bindings.classes.Foo) -> int: ... foreign_attr.pyi000066400000000000000000000002631525537303700425720ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["value"] value: demo._bindings.classes.Foo # value = foreign_class_member.pyi000066400000000000000000000003571525537303700442600ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import typing import demo._bindings.classes __all__: list[str] = ["Bar1"] class Bar1: foo: typing.ClassVar[ demo._bindings.classes.Foo ] # value = foreign_method_arg.pyi000066400000000000000000000002621525537303700437300ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar2"] class Bar2: def set_foo(self, arg0: demo._bindings.classes.Foo) -> int: ... foreign_method_return.pyi000066400000000000000000000002651525537303700445010ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar3"] class Bar3: @staticmethod def get_foo() -> demo._bindings.classes.Foo: ... foreign_return.pyi000066400000000000000000000002261525537303700431360ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["get_foo"] def get_foo() -> demo._bindings.classes.Foo: ... missing_self_arg.pyi000066400000000000000000000002541525537303700434220ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindings/aliasesfrom __future__ import annotations import demo._bindings.classes __all__: list[str] = ["Bar4"] class Bar4: def set_foo(self: demo._bindings.classes.Foo) -> int: ... classes.pyi000066400000000000000000000046021525537303700401240ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "CppException", "Derived", "Foo", "MyBase", "Outer", "ParIter", "ParIterBase", "ParticleContainer", ] class Outer: class Inner: class NestedEnum: """ Members: ONE TWO """ ONE: typing.ClassVar[Outer.Inner.NestedEnum] # value = TWO: typing.ClassVar[Outer.Inner.NestedEnum] # value = __members__: typing.ClassVar[ dict[str, Outer.Inner.NestedEnum] ] # value = {'ONE': , 'TWO': } def __eq__(self, other: typing.Any) -> bool: ... def __getstate__(self) -> int: ... def __hash__(self) -> int: ... def __index__(self) -> int: ... def __init__( self, value: typing.SupportsInt | typing.SupportsIndex ) -> None: ... def __int__(self) -> int: ... def __ne__(self, other: typing.Any) -> bool: ... def __repr__(self) -> str: ... def __setstate__( self, state: typing.SupportsInt | typing.SupportsIndex ) -> None: ... def __str__(self) -> str: ... @property def name(self) -> str: ... @property def value(self) -> int: ... value: Outer.Inner.NestedEnum inner: Outer.Inner class MyBase: class Inner: pass name: str class Derived(MyBase): @property def count(self) -> int: ... @count.setter def count(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None: ... class Foo: class FooChild: def __init__(self) -> None: ... def g(self) -> None: ... def __init__(self) -> None: ... def f(self) -> None: ... class ParIterBase: @property def level(self) -> int: ... @level.setter def level(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None: ... class ParIter(ParIterBase): def __init__( self, particle_container: ParticleContainer, level: typing.SupportsInt | typing.SupportsIndex, ) -> None: ... class ParticleContainer: name: str Iterator = ParIter def process(self, arg0: ParIter) -> None: ... class CppException(Exception): pass eigen.pyi000066400000000000000000000045421525537303700375610ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing import numpy import numpy.typing import scipy.sparse __all__: list[str] = [ "accept_matrix_int", "accept_vector_float64", "dense_matrix_c", "dense_matrix_r", "fixed_mutator_a", "fixed_mutator_c", "fixed_mutator_r", "four_col_matrix_r", "four_row_matrix_r", "get_matrix_int", "get_vector_float64", "sparse_matrix_c", "sparse_matrix_r", ] def accept_matrix_int( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.int32, "[3, 3]"], ) -> None: ... def accept_vector_float64( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, "[3, 1]"], ) -> None: ... def dense_matrix_c( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.float32, "[m, n]"], ) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[m, n]"]: ... def dense_matrix_r( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.float32, "[m, n]"], ) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[m, n]"]: ... def fixed_mutator_a( arg0: typing.Annotated[ numpy.typing.NDArray[numpy.float32], "[5, 6]", "flags.writeable" ], ) -> None: ... def fixed_mutator_c( arg0: typing.Annotated[ numpy.typing.NDArray[numpy.float32], "[5, 6]", "flags.writeable", "flags.f_contiguous", ], ) -> None: ... def fixed_mutator_r( arg0: typing.Annotated[ numpy.typing.NDArray[numpy.float32], "[5, 6]", "flags.writeable", "flags.c_contiguous", ], ) -> None: ... def four_col_matrix_r( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.float32, "[m, 4]"], ) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[m, 4]"]: ... def four_row_matrix_r( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.float32, "[4, n]"], ) -> typing.Annotated[numpy.typing.NDArray[numpy.float32], "[4, n]"]: ... def get_matrix_int() -> typing.Annotated[ numpy.typing.NDArray[numpy.int32], "[3, 3]" ]: ... def get_vector_float64() -> typing.Annotated[ numpy.typing.NDArray[numpy.float64], "[3, 1]" ]: ... def sparse_matrix_c( arg0: typing.Annotated[scipy.sparse.csc_matrix, numpy.float32], ) -> typing.Annotated[scipy.sparse.csc_matrix, numpy.float32]: ... def sparse_matrix_r( arg0: typing.Annotated[scipy.sparse.csr_matrix, numpy.float32], ) -> typing.Annotated[scipy.sparse.csr_matrix, numpy.float32]: ... enum.pyi000066400000000000000000000051701525537303700374340ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import enum import typing __all__: list[str] = [ "Blue", "ConsoleForegroundColor", "Green", "Magenta", "NativeColor", "None_", "Yellow", "accept_defaulted_enum", ] class ConsoleForegroundColor: """ Members: Green Yellow Blue Magenta None_ """ Blue: typing.ClassVar[ ConsoleForegroundColor ] # value = Green: typing.ClassVar[ ConsoleForegroundColor ] # value = Magenta: typing.ClassVar[ ConsoleForegroundColor ] # value = None_: typing.ClassVar[ ConsoleForegroundColor ] # value = Yellow: typing.ClassVar[ ConsoleForegroundColor ] # value = __members__: typing.ClassVar[ dict[str, ConsoleForegroundColor] ] # value = {'Green': , 'Yellow': , 'Blue': , 'Magenta': , 'None_': } def __eq__(self, other: typing.Any) -> bool: ... def __getstate__(self) -> int: ... def __hash__(self) -> int: ... def __index__(self) -> int: ... def __init__(self, value: typing.SupportsInt | typing.SupportsIndex) -> None: ... def __int__(self) -> int: ... def __ne__(self, other: typing.Any) -> bool: ... def __repr__(self) -> str: ... def __setstate__( self, state: typing.SupportsInt | typing.SupportsIndex ) -> None: ... def __str__(self) -> str: ... @property def name(self) -> str: ... @property def value(self) -> int: ... class NativeColor(enum.IntEnum): Blue: typing.ClassVar[NativeColor] # value = Red: typing.ClassVar[NativeColor] # value = @classmethod def __new__(cls, value): ... def __format__(self, format_spec): """ Convert to a string according to format_spec. """ def accept_defaulted_enum( color: ConsoleForegroundColor = ConsoleForegroundColor.None_, ) -> None: ... Blue: ConsoleForegroundColor # value = Green: ConsoleForegroundColor # value = Magenta: ConsoleForegroundColor # value = None_: ConsoleForegroundColor # value = Yellow: ConsoleForegroundColor # value = flawed_bindings.pyi000066400000000000000000000011461525537303700416060ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "Enum", "Unbound", "accept_unbound_enum", "accept_unbound_enum_defaulted", "accept_unbound_type", "accept_unbound_type_defaulted", "get_unbound_type", ] class Unbound: pass class Enum: pass def accept_unbound_enum(arg0: ...) -> int: ... def accept_unbound_enum_defaulted(x: Enum = ...) -> int: ... def accept_unbound_type( arg0: tuple[..., typing.SupportsInt | typing.SupportsIndex], ) -> int: ... def accept_unbound_type_defaulted(x: Unbound = ...) -> int: ... def get_unbound_type() -> ...: ... functions.pyi000066400000000000000000000066321525537303700405040ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import collections.abc import typing __all__: list[str] = [ "Foo", "accept_annotated_callable", "accept_callable", "accept_frozenset", "accept_py_handle", "accept_py_object", "accept_set", "add", "default_custom_arg", "default_int_arg", "default_list_arg", "default_optional_arg", "func_w_anon_args", "func_w_named_pos_args", "generic", "mul", "nested_types", "pass_callback", "passthrough1", "passthrough2", "passthrough3", "passthrough_backwards", "pos_kw_only_mix", "pos_kw_only_variadic_mix", ] class Foo: def __init__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None: ... def accept_annotated_callable( arg0: collections.abc.Callable[ [ typing.SupportsInt | typing.SupportsIndex, typing.SupportsInt | typing.SupportsIndex, ], int, ], ) -> typing.Any: ... def accept_callable(arg0: collections.abc.Callable) -> typing.Any: ... def accept_frozenset(arg0: frozenset) -> None: ... def accept_py_handle(arg0: typing.Any) -> str: ... def accept_py_object(arg0: typing.Any) -> str: ... def accept_set(arg0: set) -> None: ... def add( arg0: typing.SupportsInt | typing.SupportsIndex, arg1: typing.SupportsInt | typing.SupportsIndex, ) -> int: ... def default_custom_arg(foo: Foo = Foo(5)) -> None: ... def default_int_arg(n: typing.SupportsInt | typing.SupportsIndex = 5) -> None: ... def default_list_arg(l: list = [1, 2, 6, 18]) -> None: ... def default_optional_arg( n: typing.SupportsInt | typing.SupportsIndex | None = None, ) -> None: ... def func_w_anon_args( arg0: typing.SupportsInt | typing.SupportsIndex, arg1: typing.SupportsInt | typing.SupportsIndex, arg2: typing.SupportsInt | typing.SupportsIndex, ) -> None: ... def func_w_named_pos_args( x: typing.SupportsInt | typing.SupportsIndex, y: typing.SupportsInt | typing.SupportsIndex, z: typing.SupportsInt | typing.SupportsIndex, ) -> None: ... def generic(*args, **kwargs) -> None: ... @typing.overload def mul( x: typing.SupportsInt | typing.SupportsIndex, y: typing.SupportsInt | typing.SupportsIndex, ) -> int: """ Multiply x and y (int) """ @typing.overload def mul( p: typing.SupportsFloat | typing.SupportsIndex, q: typing.SupportsFloat | typing.SupportsIndex, ) -> float: """ Multiply p and q (double) """ def nested_types(arg0: collections.abc.Sequence[Foo] | Foo) -> list[Foo] | Foo: ... def pass_callback(arg0: collections.abc.Callable[[Foo], Foo]) -> Foo: ... def passthrough1[T](obj: T) -> T: ... @typing.overload def passthrough2() -> None: ... @typing.overload def passthrough2[T](obj: T) -> T: ... @typing.overload def passthrough3() -> tuple[None, None]: ... @typing.overload def passthrough3[T](obj: T) -> tuple[T, None]: ... @typing.overload def passthrough3[T1, T2](obj1: T1, obj2: T2) -> tuple[T1, T2]: ... def passthrough_backwards[T](obj: T) -> T: ... def pos_kw_only_mix( i: typing.SupportsInt | typing.SupportsIndex, /, j: typing.SupportsInt | typing.SupportsIndex, *, k: typing.SupportsInt | typing.SupportsIndex, ) -> tuple[int, int, int]: ... def pos_kw_only_variadic_mix( i: typing.SupportsInt | typing.SupportsIndex, /, j: typing.SupportsInt | typing.SupportsIndex, *args, k: typing.SupportsInt | typing.SupportsIndex, **kwargs, ) -> tuple[int, int, int]: ... hidden_builtins.pyi000066400000000000000000000002571525537303700416350ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import types __all__: list[str] = ["mapping_proxy", "none"] mapping_proxy: types.MappingProxyType # value = mappingproxy({}) none = None issues.pyi000066400000000000000000000022401525537303700377760ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "backslashes_should_be_escaped", "issue_51_catastrophic_regex", "issue_73_utf8_doc_chars", "issue_274_docstring_leading_newline", ] def backslashes_should_be_escaped() -> None: """ \\brief A brief description of this function. A detailed description of this function. Here's some reStructuredText: :math:`x = [x, y, \\theta]^T` """ def issue_274_docstring_leading_newline() -> None: """ This is a docstring """ def issue_51_catastrophic_regex( arg0: typing.SupportsInt | typing.SupportsIndex, arg1: typing.SupportsInt | typing.SupportsIndex, ) -> None: """ Use-case: issue_51(os.get_handle_inheritable, os.set_handle_inheritable) """ def issue_73_utf8_doc_chars() -> None: """ Construct a Ramsete unicycle controller. Tuning parameter (b > 0 rad²/m²) for which larger values make convergence more aggressive like a proportional term. Tuning parameter (0 rad⁻¹ < zeta < 1 rad⁻¹) for which larger values provide more damping in response. """ _cleanup: typing.Any # value = methods.pyi000066400000000000000000000004551525537303700401340ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = ["Dummy"] class Dummy: @staticmethod def static_method(arg0: typing.SupportsInt | typing.SupportsIndex) -> int: ... def regular_method( self, arg0: typing.SupportsInt | typing.SupportsIndex ) -> int: ... numpy.pyi000066400000000000000000000011741525537303700376400ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing import numpy import numpy.typing __all__: list[str] = [ "accept_ndarray_float64", "accept_ndarray_int", "get_ndarray_float64", "get_ndarray_int", "return_dtype", ] def accept_ndarray_float64( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.float64], ) -> None: ... def accept_ndarray_int( arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.int32], ) -> None: ... def get_ndarray_float64() -> numpy.typing.NDArray[numpy.float64]: ... def get_ndarray_int() -> numpy.typing.NDArray[numpy.int32]: ... def return_dtype() -> numpy.dtype[typing.Any]: ... properties.pyi000066400000000000000000000060211525537303700406600ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import typing __all__: list[str] = [ "WithGetterSetterDoc", "WithPropAndGetterSetterDoc", "WithPropDoc", "WithoutDoc", ] class WithoutDoc: """ No user docstring provided """ def_property_readonly_static: typing.ClassVar[int] = 0 def_property_static: typing.ClassVar[int] = 0 @property def def_property(self) -> int: ... @def_property.setter def def_property(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None: ... @property def def_property_readonly(self) -> int: ... @property def def_readonly(self) -> int: ... @property def def_readwrite(self) -> int: ... @def_readwrite.setter def def_readwrite( self, arg0: typing.SupportsInt | typing.SupportsIndex ) -> None: ... class WithPropDoc: """ User docstring provided only to `def_` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 """ prop doc token """ def_property_static: typing.ClassVar[int] = 0 """ prop doc token """ @property def def_property(self) -> int: """ prop doc token """ @def_property.setter def def_property(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None: ... @property def def_property_readonly(self) -> int: """ prop doc token """ @property def def_readonly(self) -> int: """ prop doc token """ @property def def_readwrite(self) -> int: """ prop doc token """ @def_readwrite.setter def def_readwrite( self, arg0: typing.SupportsInt | typing.SupportsIndex ) -> None: ... class WithGetterSetterDoc: """ User docstring provided via pybind11::cpp_function(..., doc) to getters/setters, but NOT to `def_*(..., doc)` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 """ getter doc token """ def_property_static: typing.ClassVar[int] = 0 """ getter doc token """ @property def def_property(self) -> int: """ getter doc token """ @def_property.setter def def_property(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None: """ setter doc token """ @property def def_property_readonly(self) -> int: """ getter doc token """ class WithPropAndGetterSetterDoc: """ User docstring provided via pybind11::cpp_function(..., doc) to getters/setters and to `def_*(, doc)` calls """ def_property_readonly_static: typing.ClassVar[int] = 0 """ prop doc token """ def_property_static: typing.ClassVar[int] = 0 """ prop doc token """ @property def def_property(self) -> int: """ prop doc token """ @def_property.setter def def_property(self, arg1: typing.SupportsInt | typing.SupportsIndex) -> None: ... @property def def_property_readonly(self) -> int: """ prop doc token """ stl.pyi000066400000000000000000000015021525537303700372650ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import collections.abc import typing __all__: list[str] = [ "std_array", "std_map", "std_optional", "std_variant", "std_vector", ] def std_array( arg0: typing.Annotated[ collections.abc.Sequence[typing.SupportsInt | typing.SupportsIndex], "FixedSize(3)", ], ) -> typing.Annotated[list[int], "FixedSize(3)"]: ... def std_map() -> dict[int, complex]: ... def std_optional(arg0: typing.SupportsInt | typing.SupportsIndex | None) -> None: ... def std_variant( arg0: typing.SupportsInt | typing.SupportsIndex | typing.SupportsFloat | typing.SupportsIndex | tuple[ typing.SupportsInt | typing.SupportsIndex, typing.SupportsInt | typing.SupportsIndex, ], ) -> None: ... def std_vector() -> list[tuple[int, float]]: ... stl_bind.pyi000066400000000000000000000110261525537303700402630ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import collections.abc import typing __all__: list[str] = [ "MapStringComplex", "VectorPairStringDouble", "get_complex_map", "get_vector_of_pairs", ] class VectorPairStringDouble: __hash__: typing.ClassVar[None] = None def __bool__(self) -> bool: """ Check whether the list is nonempty """ def __contains__( self, x: tuple[str, typing.SupportsFloat | typing.SupportsIndex] ) -> bool: """ Return true the container contains ``x`` """ @typing.overload def __delitem__(self, arg0: typing.SupportsInt | typing.SupportsIndex) -> None: """ Delete the list elements at index ``i`` """ @typing.overload def __delitem__(self, arg0: slice) -> None: """ Delete list elements using a slice object """ def __eq__(self, arg0: VectorPairStringDouble) -> bool: ... @typing.overload def __getitem__(self, s: slice) -> VectorPairStringDouble: """ Retrieve list elements using a slice object """ @typing.overload def __getitem__( self, arg0: typing.SupportsInt | typing.SupportsIndex ) -> tuple[str, float]: ... @typing.overload def __init__(self) -> None: ... @typing.overload def __init__(self, arg0: VectorPairStringDouble) -> None: """ Copy constructor """ @typing.overload def __init__(self, arg0: collections.abc.Iterable) -> None: ... def __iter__(self) -> collections.abc.Iterator[tuple[str, float]]: ... def __len__(self) -> int: ... def __ne__(self, arg0: VectorPairStringDouble) -> bool: ... @typing.overload def __setitem__( self, arg0: typing.SupportsInt | typing.SupportsIndex, arg1: tuple[str, typing.SupportsFloat | typing.SupportsIndex], ) -> None: ... @typing.overload def __setitem__(self, arg0: slice, arg1: VectorPairStringDouble) -> None: """ Assign list elements using a slice object """ def append( self, x: tuple[str, typing.SupportsFloat | typing.SupportsIndex] ) -> None: """ Add an item to the end of the list """ def clear(self) -> None: """ Clear the contents """ def count(self, x: tuple[str, typing.SupportsFloat | typing.SupportsIndex]) -> int: """ Return the number of times ``x`` appears in the list """ @typing.overload def extend(self, L: VectorPairStringDouble) -> None: """ Extend the list by appending all the items in the given list """ @typing.overload def extend(self, L: collections.abc.Iterable) -> None: """ Extend the list by appending all the items in the given list """ def insert( self, i: typing.SupportsInt | typing.SupportsIndex, x: tuple[str, typing.SupportsFloat | typing.SupportsIndex], ) -> None: """ Insert an item at a given position. """ @typing.overload def pop(self) -> tuple[str, float]: """ Remove and return the last item """ @typing.overload def pop(self, i: typing.SupportsInt | typing.SupportsIndex) -> tuple[str, float]: """ Remove and return the item at index ``i`` """ def remove( self, x: tuple[str, typing.SupportsFloat | typing.SupportsIndex] ) -> None: """ Remove the first item from the list whose value is x. It is an error if there is no such item. """ class MapStringComplex: def __bool__(self) -> bool: """ Check whether the map is nonempty """ @typing.overload def __contains__(self, arg0: str) -> bool: ... @typing.overload def __contains__(self, arg0: typing.Any) -> bool: ... def __delitem__(self, arg0: str) -> None: ... def __getitem__(self, arg0: str) -> complex: ... def __init__(self) -> None: ... def __iter__(self) -> collections.abc.Iterator[str]: ... def __len__(self) -> int: ... def __repr__(self) -> str: """ Return the canonical string representation of this map. """ def __setitem__( self, arg0: str, arg1: typing.SupportsComplex | typing.SupportsFloat | typing.SupportsIndex, ) -> None: ... def items(self) -> typing.ItemsView: ... def keys(self) -> typing.KeysView: ... def values(self) -> typing.ValuesView: ... def get_complex_map() -> MapStringComplex: ... def get_vector_of_pairs() -> VectorPairStringDouble: ... typing.pyi000066400000000000000000000004171525537303700400010ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import collections.abc __all__: list[str] = ["get_buffer", "get_sequence"] def get_buffer(arg0: collections.abc.Buffer) -> collections.abc.Buffer: ... def get_sequence(arg0: collections.abc.Sequence) -> collections.abc.Sequence: ... values.pyi000066400000000000000000000014521525537303700377660ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import datetime import numpy from numpy import random __all__: list[str] = [ "Dummy", "Foo", "add_day", "foolist", "foovar", "list_with_none", "none", "random", "t_10ms", "t_20ns", "t_30s", ] class Dummy: linalg = numpy.linalg class Foo: pass def add_day(arg0: datetime.datetime) -> datetime.datetime: ... foolist: list # value = [, ] foovar: Foo # value = list_with_none: list = [None, 2, {}] none = None t_10ms: datetime.timedelta # value = datetime.timedelta(microseconds=10000) t_20ns: datetime.timedelta # value = datetime.timedelta(0) t_30s: datetime.timedelta # value = datetime.timedelta(seconds=30) core.pyi000066400000000000000000000010211525537303700354530ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-wrap-with-annotated/demofrom __future__ import annotations from demo._bindings import ( aliases, classes, eigen, enum, flawed_bindings, functions, hidden_builtins, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) __all__: list[str] = [ "aliases", "classes", "eigen", "enum", "flawed_bindings", "functions", "hidden_builtins", "issues", "methods", "numpy", "properties", "stl", "stl_bind", "typing", "values", ] pure_python/000077500000000000000000000000001525537303700363625ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-wrap-with-annotated/demo__init__.pyi000066400000000000000000000003611525537303700406440ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations from . import classes, functions, functions_3_8_plus, functions_3_9_plus, values __all__: list[str] = [ "classes", "functions", "functions_3_8_plus", "functions_3_9_plus", "values", ] classes.pyi000066400000000000000000000003071525537303700405420ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["A", "B", "C", "X"] class A: """ A """ class B(A): """ B """ class C(B): """ C """ class X: pass functions.pyi000066400000000000000000000015561525537303700411240ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations import sys as sys import typing as typing from demo.pure_python.functions_3_8_plus import args_mix from demo.pure_python.functions_3_9_plus import generic_alias_annotation __all__: list[str] = [ "accept_frozenset", "args_mix", "builtin_function_as_default_arg", "function_as_default_arg", "generic_alias_annotation", "lambda_as_default_arg", "search", "static_method_as_default_arg", "sys", "typing", ] class _Dummy: @staticmethod def foo(): ... def accept_frozenset(arg: frozenset[int | float]) -> int | None: ... def builtin_function_as_default_arg(func: type(len) = len): ... def function_as_default_arg(func: type(search) = search): ... def lambda_as_default_arg(callback=...): ... def search(a: int, b: list[int]) -> int: ... def static_method_as_default_arg(callback=_Dummy.foo): ... functions_3_8_plus.pyi000066400000000000000000000007761525537303700426430ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations import typing as typing __all__: list[str] = [ "Expression", "Token", "args_mix", "nested_current_module_annotations", "typing", ] class Token: pass class Expression: pass def args_mix( a: int, b: float = 0.5, c: str = "", *args: int, x: int = 1, y=int, **kwargs: dict[int, str], ): ... def nested_current_module_annotations( tokens: list[Token], expr: Expression | None = None ) -> dict[str, Expression]: ... functions_3_9_plus.pyi000066400000000000000000000002601525537303700426300ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["generic_alias_annotation"] def generic_alias_annotation(a: list[tuple[int]], b: dict[int, str]) -> list[float]: ... values.pyi000066400000000000000000000001741525537303700404060ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.12/pybind11-v3.0/numpy-array-wrap-with-annotated/demo/pure_pythonfrom __future__ import annotations __all__: list[str] = ["callables_dict"] callables_dict: dict = {"len": len, "int": int} pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.13000077700000000000000000000000001525537303700244132python-3.12ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.8/000077500000000000000000000000001525537303700225745ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.8/pybind11-v2.13/000077500000000000000000000000001525537303700247725ustar00rootroot00000000000000numpy-array-wrap-with-annotated/000077500000000000000000000000001525537303700330725ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.8/pybind11-v2.13demo/000077500000000000000000000000001525537303700340165ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.8/pybind11-v2.13/numpy-array-wrap-with-annotated_bindings/000077500000000000000000000000001525537303700357525ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.8/pybind11-v2.13/numpy-array-wrap-with-annotated/demo__init__.pyi000066400000000000000000000010041525537303700402270ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.8/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations from . import ( aliases, classes, eigen, enum, flawed_bindings, functions, hidden_builtins, issues, methods, numpy, properties, stl, stl_bind, typing, values, ) __all__: list[str] = [ "aliases", "classes", "eigen", "enum", "flawed_bindings", "functions", "hidden_builtins", "issues", "methods", "numpy", "properties", "stl", "stl_bind", "typing", "values", ] hidden_builtins.pyi000066400000000000000000000002331525537303700416370ustar00rootroot00000000000000pybind-pybind11-stubgen-c8167c3/tests/stubs/python-3.8/pybind11-v2.13/numpy-array-wrap-with-annotated/demo/_bindingsfrom __future__ import annotations import types __all__: list[str] = ["mapping_proxy"] mapping_proxy: types.MappingProxyType # value = mappingproxy({}) pybind-pybind11-stubgen-c8167c3/tox.ini000066400000000000000000000033261525537303700177620ustar00rootroot00000000000000[tox] requires = tox>=4 uv_mode = true env_list = py313-pb30-nutv py{310,311,312,313}-pb30-naa py{310,311,312,313}-pb213-naa py313-pb29-naa py313-pb211-naa py313-pb212-naa py313-pb213-nutv skipsdist = true isolated_build = true [testenv] description = Regenerate stubs in tests/stubs/ package = skip setenv = PYTHONUNBUFFERED = 1 pb29: PYBIND11_BRANCH = v2.9 pb211: PYBIND11_BRANCH = v2.11 pb212: PYBIND11_BRANCH = v2.12 pb213: PYBIND11_BRANCH = v2.13 pb30: PYBIND11_BRANCH = v3.0 naa: NUMPY_FORMAT = numpy-array-wrap-with-annotated nutv: NUMPY_FORMAT = numpy-array-use-type-var PROJECT_ROOT = {toxinidir} TESTS_ROOT = {env:PROJECT_ROOT}/tests STUBS_OUT = {toxinidir}/tests/stubs PYTHON_TAG_FILE = {envtmpdir}/python_tag.env CMAKE = {envbindir}/cmake allowlist_externals = bash git deps = cmeel==0.59.0 cmeel-eigen==3.4.0.2 numpy~=1.20 scipy~=1.0 typing_extensions>=4,<5 pb29: cmake==3.31.* pb211: cmake==3.28.3 pb212: cmake==3.28.3 pb213: cmake==4.2.* pb30: cmake==4.2.* commands_pre = bash -c 'cmake="${CMAKE}" {env:TESTS_ROOT}/install-demo-module.sh' {envpython} -c "import os,sys; p=os.environ['PYTHON_TAG_FILE']; v=f'python-{sys.version_info.major}.{sys.version_info.minor}'; open(p,'w').write(f'PYTHON_TAG={v}\n'); print(v)" commands = {envpython} -m pip install . bash -c 'set -a; source "{env:PYTHON_TAG_FILE}"; set +a; \ {env:TESTS_ROOT}/check-demo-stubs-generation.sh --stubs-sub-dir "stubs/${PYTHON_TAG}/pybind11-{env:PYBIND11_BRANCH}/{env:NUMPY_FORMAT}" --{env:NUMPY_FORMAT}' bash {env:TESTS_ROOT}/check-demo-errors-generation.sh "pybind11-{env:PYBIND11_BRANCH}" pybind-pybind11-stubgen-c8167c3/uv.lock000066400000000000000000003522621525537303700177610ustar00rootroot00000000000000version = 1 revision = 3 requires-python = ">=3.10" resolution-markers = [ "python_full_version >= '3.11'", "python_full_version < '3.11'", ] [[package]] name = "cfgv" version = "3.5.0" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/4e/b5/721b8799b04bf9afe054a3899c6cf4e880fcf8563cc71c15610242490a0c/cfgv-3.5.0.tar.gz", hash = "sha256:d5b1034354820651caa73ede66a6294d6e95c1b00acc5e9b098e917404669132", size = 7334, upload-time = "2025-11-19T20:55:51.612Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/db/3c/33bac158f8ab7f89b2e59426d5fe2e4f63f7ed25df84c036890172b412b5/cfgv-3.5.0-py2.py3-none-any.whl", hash = "sha256:a8dc6b26ad22ff227d2634a65cb388215ce6cc96bbcc5cfde7641ae87e8dacc0", size = 7445, upload-time = "2025-11-19T20:55:50.744Z" }, ] [[package]] name = "cmeel" version = "0.59.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "tomli", marker = "python_full_version < '3.11'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/85/58/2448af92b3761a1b321014a653f79d322026681728f96ebe9f419ae0d6b8/cmeel-0.59.0.tar.gz", hash = "sha256:d9871f96ad0499c1cf8671e69622c805265a6be4383a1abfd18f20b4a33e3e3a", size = 14890, upload-time = "2026-01-19T11:48:25.431Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/90/c7/f7a2ea2e88cba4828c9b5bba5b8448ad6e6cbd652d782cc97bb14a54e6a6/cmeel-0.59.0-py3-none-any.whl", hash = "sha256:04a24b960e602484306721ce148610ddda4cbc83b8c5f27ef915366a86901e06", size = 20991, upload-time = "2026-01-19T11:48:24.259Z" }, ] [[package]] name = "cmeel-eigen" version = "3.4.0.2" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "cmeel" }, ] sdist = { url = "https://files.pythonhosted.org/packages/97/f3/6ff10912e6f381e6ed804680d79c04cf8f4c6d5530b1c5444b17c0e10769/cmeel_eigen-3.4.0.2.tar.gz", hash = "sha256:4c6b712ed66126f397a598e416e0903b6407bae65ddb7905d29ac4fbef550ade", size = 2721887, upload-time = "2023-11-16T00:21:57.453Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/d1/c8/bf03f1684bdcc61f2c2cce2f8ab7d13289c67f0f6bb58288d30c318df183/cmeel_eigen-3.4.0.2-0-py3-none-any.whl", hash = "sha256:2c3efe70560aca10b9d5b9bac6c883057d30aa08fc7b8cb43f4837e935b214e4", size = 1883353, upload-time = "2023-11-16T00:21:54.205Z" }, ] [[package]] name = "distlib" version = "0.4.0" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/96/8e/709914eb2b5749865801041647dc7f4e6d00b549cfe88b65ca192995f07c/distlib-0.4.0.tar.gz", hash = "sha256:feec40075be03a04501a973d81f633735b4b69f98b05450592310c0f401a4e0d", size = 614605, upload-time = "2025-07-17T16:52:00.465Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/33/6b/e0547afaf41bf2c42e52430072fa5658766e3d65bd4b03a563d1b6336f57/distlib-0.4.0-py2.py3-none-any.whl", hash = "sha256:9659f7d87e46584a30b5780e43ac7a2143098441670ff0a49d5f9034c54a6c16", size = 469047, upload-time = "2025-07-17T16:51:58.613Z" }, ] [[package]] name = "filelock" version = "3.29.0" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/b5/fe/997687a931ab51049acce6fa1f23e8f01216374ea81374ddee763c493db5/filelock-3.29.0.tar.gz", hash = "sha256:69974355e960702e789734cb4871f884ea6fe50bd8404051a3530bc07809cf90", size = 57571, upload-time = "2026-04-19T15:39:10.068Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/81/47/dd9a212ef6e343a6857485ffe25bba537304f1913bdbed446a23f7f592e1/filelock-3.29.0-py3-none-any.whl", hash = "sha256:96f5f6344709aa1572bbf631c640e4ebeeb519e08da902c39a001882f30ac258", size = 39812, upload-time = "2026-04-19T15:39:08.752Z" }, ] [[package]] name = "identify" version = "2.6.19" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/52/63/51723b5f116cc04b061cb6f5a561790abf249d25931d515cd375e063e0f4/identify-2.6.19.tar.gz", hash = "sha256:6be5020c38fcb07da56c53733538a3081ea5aa70d36a156f83044bfbf9173842", size = 99567, upload-time = "2026-04-17T18:39:50.265Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/94/84/d9273cd09688070a6523c4aee4663a8538721b2b755c4962aafae0011e72/identify-2.6.19-py2.py3-none-any.whl", hash = "sha256:20e6a87f786f768c092a721ad107fc9df0eb89347be9396cadf3f4abbd1fb78a", size = 99397, upload-time = "2026-04-17T18:39:49.221Z" }, ] [[package]] name = "librt" version = "0.7.8" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/e7/24/5f3646ff414285e0f7708fa4e946b9bf538345a41d1c375c439467721a5e/librt-0.7.8.tar.gz", hash = "sha256:1a4ede613941d9c3470b0368be851df6bb78ab218635512d0370b27a277a0862", size = 148323, upload-time = "2026-01-14T12:56:16.876Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/44/13/57b06758a13550c5f09563893b004f98e9537ee6ec67b7df85c3571c8832/librt-0.7.8-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b45306a1fc5f53c9330fbee134d8b3227fe5da2ab09813b892790400aa49352d", size = 56521, upload-time = "2026-01-14T12:54:40.066Z" }, { url = "https://files.pythonhosted.org/packages/c2/24/bbea34d1452a10612fb45ac8356f95351ba40c2517e429602160a49d1fd0/librt-0.7.8-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:864c4b7083eeee250ed55135d2127b260d7eb4b5e953a9e5df09c852e327961b", size = 58456, upload-time = "2026-01-14T12:54:41.471Z" }, { url = "https://files.pythonhosted.org/packages/04/72/a168808f92253ec3a810beb1eceebc465701197dbc7e865a1c9ceb3c22c7/librt-0.7.8-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:6938cc2de153bc927ed8d71c7d2f2ae01b4e96359126c602721340eb7ce1a92d", size = 164392, upload-time = "2026-01-14T12:54:42.843Z" }, { url = "https://files.pythonhosted.org/packages/14/5c/4c0d406f1b02735c2e7af8ff1ff03a6577b1369b91aa934a9fa2cc42c7ce/librt-0.7.8-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:66daa6ac5de4288a5bbfbe55b4caa7bf0cd26b3269c7a476ffe8ce45f837f87d", size = 172959, upload-time = "2026-01-14T12:54:44.602Z" }, { url = "https://files.pythonhosted.org/packages/82/5f/3e85351c523f73ad8d938989e9a58c7f59fb9c17f761b9981b43f0025ce7/librt-0.7.8-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4864045f49dc9c974dadb942ac56a74cd0479a2aafa51ce272c490a82322ea3c", size = 186717, upload-time = "2026-01-14T12:54:45.986Z" }, { url = "https://files.pythonhosted.org/packages/08/f8/18bfe092e402d00fe00d33aa1e01dda1bd583ca100b393b4373847eade6d/librt-0.7.8-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:a36515b1328dc5b3ffce79fe204985ca8572525452eacabee2166f44bb387b2c", size = 184585, upload-time = "2026-01-14T12:54:47.139Z" }, { url = "https://files.pythonhosted.org/packages/4e/fc/f43972ff56fd790a9fa55028a52ccea1875100edbb856b705bd393b601e3/librt-0.7.8-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:b7e7f140c5169798f90b80d6e607ed2ba5059784968a004107c88ad61fb3641d", size = 180497, upload-time = "2026-01-14T12:54:48.946Z" }, { url = "https://files.pythonhosted.org/packages/e1/3a/25e36030315a410d3ad0b7d0f19f5f188e88d1613d7d3fd8150523ea1093/librt-0.7.8-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:ff71447cb778a4f772ddc4ce360e6ba9c95527ed84a52096bd1bbf9fee2ec7c0", size = 200052, upload-time = "2026-01-14T12:54:50.382Z" }, { url = "https://files.pythonhosted.org/packages/fc/b8/f3a5a1931ae2a6ad92bf6893b9ef44325b88641d58723529e2c2935e8abe/librt-0.7.8-cp310-cp310-win32.whl", hash = "sha256:047164e5f68b7a8ebdf9fae91a3c2161d3192418aadd61ddd3a86a56cbe3dc85", size = 43477, upload-time = "2026-01-14T12:54:51.815Z" }, { url = "https://files.pythonhosted.org/packages/fe/91/c4202779366bc19f871b4ad25db10fcfa1e313c7893feb942f32668e8597/librt-0.7.8-cp310-cp310-win_amd64.whl", hash = "sha256:d6f254d096d84156a46a84861183c183d30734e52383602443292644d895047c", size = 49806, upload-time = "2026-01-14T12:54:53.149Z" }, { url = "https://files.pythonhosted.org/packages/1b/a3/87ea9c1049f2c781177496ebee29430e4631f439b8553a4969c88747d5d8/librt-0.7.8-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ff3e9c11aa260c31493d4b3197d1e28dd07768594a4f92bec4506849d736248f", size = 56507, upload-time = "2026-01-14T12:54:54.156Z" }, { url = "https://files.pythonhosted.org/packages/5e/4a/23bcef149f37f771ad30203d561fcfd45b02bc54947b91f7a9ac34815747/librt-0.7.8-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ddb52499d0b3ed4aa88746aaf6f36a08314677d5c346234c3987ddc506404eac", size = 58455, upload-time = "2026-01-14T12:54:55.978Z" }, { url = "https://files.pythonhosted.org/packages/22/6e/46eb9b85c1b9761e0f42b6e6311e1cc544843ac897457062b9d5d0b21df4/librt-0.7.8-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:e9c0afebbe6ce177ae8edba0c7c4d626f2a0fc12c33bb993d163817c41a7a05c", size = 164956, upload-time = "2026-01-14T12:54:57.311Z" }, { url = "https://files.pythonhosted.org/packages/7a/3f/aa7c7f6829fb83989feb7ba9aa11c662b34b4bd4bd5b262f2876ba3db58d/librt-0.7.8-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:631599598e2c76ded400c0a8722dec09217c89ff64dc54b060f598ed68e7d2a8", size = 174364, upload-time = "2026-01-14T12:54:59.089Z" }, { url = "https://files.pythonhosted.org/packages/3f/2d/d57d154b40b11f2cb851c4df0d4c4456bacd9b1ccc4ecb593ddec56c1a8b/librt-0.7.8-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c1ba843ae20db09b9d5c80475376168feb2640ce91cd9906414f23cc267a1ff", size = 188034, upload-time = "2026-01-14T12:55:00.141Z" }, { url = "https://files.pythonhosted.org/packages/59/f9/36c4dad00925c16cd69d744b87f7001792691857d3b79187e7a673e812fb/librt-0.7.8-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b5b007bb22ea4b255d3ee39dfd06d12534de2fcc3438567d9f48cdaf67ae1ae3", size = 186295, upload-time = "2026-01-14T12:55:01.303Z" }, { url = "https://files.pythonhosted.org/packages/23/9b/8a9889d3df5efb67695a67785028ccd58e661c3018237b73ad081691d0cb/librt-0.7.8-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:dbd79caaf77a3f590cbe32dc2447f718772d6eea59656a7dcb9311161b10fa75", size = 181470, upload-time = "2026-01-14T12:55:02.492Z" }, { url = "https://files.pythonhosted.org/packages/43/64/54d6ef11afca01fef8af78c230726a9394759f2addfbf7afc5e3cc032a45/librt-0.7.8-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:87808a8d1e0bd62a01cafc41f0fd6818b5a5d0ca0d8a55326a81643cdda8f873", size = 201713, upload-time = "2026-01-14T12:55:03.919Z" }, { url = "https://files.pythonhosted.org/packages/2d/29/73e7ed2991330b28919387656f54109139b49e19cd72902f466bd44415fd/librt-0.7.8-cp311-cp311-win32.whl", hash = "sha256:31724b93baa91512bd0a376e7cf0b59d8b631ee17923b1218a65456fa9bda2e7", size = 43803, upload-time = "2026-01-14T12:55:04.996Z" }, { url = "https://files.pythonhosted.org/packages/3f/de/66766ff48ed02b4d78deea30392ae200bcbd99ae61ba2418b49fd50a4831/librt-0.7.8-cp311-cp311-win_amd64.whl", hash = "sha256:978e8b5f13e52cf23a9e80f3286d7546baa70bc4ef35b51d97a709d0b28e537c", size = 50080, upload-time = "2026-01-14T12:55:06.489Z" }, { url = "https://files.pythonhosted.org/packages/6f/e3/33450438ff3a8c581d4ed7f798a70b07c3206d298cf0b87d3806e72e3ed8/librt-0.7.8-cp311-cp311-win_arm64.whl", hash = "sha256:20e3946863d872f7cabf7f77c6c9d370b8b3d74333d3a32471c50d3a86c0a232", size = 43383, upload-time = "2026-01-14T12:55:07.49Z" }, { url = "https://files.pythonhosted.org/packages/56/04/79d8fcb43cae376c7adbab7b2b9f65e48432c9eced62ac96703bcc16e09b/librt-0.7.8-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:9b6943885b2d49c48d0cff23b16be830ba46b0152d98f62de49e735c6e655a63", size = 57472, upload-time = "2026-01-14T12:55:08.528Z" }, { url = "https://files.pythonhosted.org/packages/b4/ba/60b96e93043d3d659da91752689023a73981336446ae82078cddf706249e/librt-0.7.8-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:46ef1f4b9b6cc364b11eea0ecc0897314447a66029ee1e55859acb3dd8757c93", size = 58986, upload-time = "2026-01-14T12:55:09.466Z" }, { url = "https://files.pythonhosted.org/packages/7c/26/5215e4cdcc26e7be7eee21955a7e13cbf1f6d7d7311461a6014544596fac/librt-0.7.8-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:907ad09cfab21e3c86e8f1f87858f7049d1097f77196959c033612f532b4e592", size = 168422, upload-time = "2026-01-14T12:55:10.499Z" }, { url = "https://files.pythonhosted.org/packages/0f/84/e8d1bc86fa0159bfc24f3d798d92cafd3897e84c7fea7fe61b3220915d76/librt-0.7.8-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2991b6c3775383752b3ca0204842743256f3ad3deeb1d0adc227d56b78a9a850", size = 177478, upload-time = "2026-01-14T12:55:11.577Z" }, { url = "https://files.pythonhosted.org/packages/57/11/d0268c4b94717a18aa91df1100e767b010f87b7ae444dafaa5a2d80f33a6/librt-0.7.8-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:03679b9856932b8c8f674e87aa3c55ea11c9274301f76ae8dc4d281bda55cf62", size = 192439, upload-time = "2026-01-14T12:55:12.7Z" }, { url = "https://files.pythonhosted.org/packages/8d/56/1e8e833b95fe684f80f8894ae4d8b7d36acc9203e60478fcae599120a975/librt-0.7.8-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3968762fec1b2ad34ce57458b6de25dbb4142713e9ca6279a0d352fa4e9f452b", size = 191483, upload-time = "2026-01-14T12:55:13.838Z" }, { url = "https://files.pythonhosted.org/packages/17/48/f11cf28a2cb6c31f282009e2208312aa84a5ee2732859f7856ee306176d5/librt-0.7.8-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:bb7a7807523a31f03061288cc4ffc065d684c39db7644c676b47d89553c0d714", size = 185376, upload-time = "2026-01-14T12:55:15.017Z" }, { url = "https://files.pythonhosted.org/packages/b8/6a/d7c116c6da561b9155b184354a60a3d5cdbf08fc7f3678d09c95679d13d9/librt-0.7.8-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ad64a14b1e56e702e19b24aae108f18ad1bf7777f3af5fcd39f87d0c5a814449", size = 206234, upload-time = "2026-01-14T12:55:16.571Z" }, { url = "https://files.pythonhosted.org/packages/61/de/1975200bb0285fc921c5981d9978ce6ce11ae6d797df815add94a5a848a3/librt-0.7.8-cp312-cp312-win32.whl", hash = "sha256:0241a6ed65e6666236ea78203a73d800dbed896cf12ae25d026d75dc1fcd1dac", size = 44057, upload-time = "2026-01-14T12:55:18.077Z" }, { url = "https://files.pythonhosted.org/packages/8e/cd/724f2d0b3461426730d4877754b65d39f06a41ac9d0a92d5c6840f72b9ae/librt-0.7.8-cp312-cp312-win_amd64.whl", hash = "sha256:6db5faf064b5bab9675c32a873436b31e01d66ca6984c6f7f92621656033a708", size = 50293, upload-time = "2026-01-14T12:55:19.179Z" }, { url = "https://files.pythonhosted.org/packages/bd/cf/7e899acd9ee5727ad8160fdcc9994954e79fab371c66535c60e13b968ffc/librt-0.7.8-cp312-cp312-win_arm64.whl", hash = "sha256:57175aa93f804d2c08d2edb7213e09276bd49097611aefc37e3fa38d1fb99ad0", size = 43574, upload-time = "2026-01-14T12:55:20.185Z" }, { url = "https://files.pythonhosted.org/packages/a1/fe/b1f9de2829cf7fc7649c1dcd202cfd873837c5cc2fc9e526b0e7f716c3d2/librt-0.7.8-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4c3995abbbb60b3c129490fa985dfe6cac11d88fc3c36eeb4fb1449efbbb04fc", size = 57500, upload-time = "2026-01-14T12:55:21.219Z" }, { url = "https://files.pythonhosted.org/packages/eb/d4/4a60fbe2e53b825f5d9a77325071d61cd8af8506255067bf0c8527530745/librt-0.7.8-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:44e0c2cbc9bebd074cf2cdbe472ca185e824be4e74b1c63a8e934cea674bebf2", size = 59019, upload-time = "2026-01-14T12:55:22.256Z" }, { url = "https://files.pythonhosted.org/packages/6a/37/61ff80341ba5159afa524445f2d984c30e2821f31f7c73cf166dcafa5564/librt-0.7.8-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:4d2f1e492cae964b3463a03dc77a7fe8742f7855d7258c7643f0ee32b6651dd3", size = 169015, upload-time = "2026-01-14T12:55:23.24Z" }, { url = "https://files.pythonhosted.org/packages/1c/86/13d4f2d6a93f181ebf2fc953868826653ede494559da8268023fe567fca3/librt-0.7.8-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:451e7ffcef8f785831fdb791bd69211f47e95dc4c6ddff68e589058806f044c6", size = 178161, upload-time = "2026-01-14T12:55:24.826Z" }, { url = "https://files.pythonhosted.org/packages/88/26/e24ef01305954fc4d771f1f09f3dd682f9eb610e1bec188ffb719374d26e/librt-0.7.8-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3469e1af9f1380e093ae06bedcbdd11e407ac0b303a56bbe9afb1d6824d4982d", size = 193015, upload-time = "2026-01-14T12:55:26.04Z" }, { url = "https://files.pythonhosted.org/packages/88/a0/92b6bd060e720d7a31ed474d046a69bd55334ec05e9c446d228c4b806ae3/librt-0.7.8-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f11b300027ce19a34f6d24ebb0a25fd0e24a9d53353225a5c1e6cadbf2916b2e", size = 192038, upload-time = "2026-01-14T12:55:27.208Z" }, { url = "https://files.pythonhosted.org/packages/06/bb/6f4c650253704279c3a214dad188101d1b5ea23be0606628bc6739456624/librt-0.7.8-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:4adc73614f0d3c97874f02f2c7fd2a27854e7e24ad532ea6b965459c5b757eca", size = 186006, upload-time = "2026-01-14T12:55:28.594Z" }, { url = "https://files.pythonhosted.org/packages/dc/00/1c409618248d43240cadf45f3efb866837fa77e9a12a71481912135eb481/librt-0.7.8-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:60c299e555f87e4c01b2eca085dfccda1dde87f5a604bb45c2906b8305819a93", size = 206888, upload-time = "2026-01-14T12:55:30.214Z" }, { url = "https://files.pythonhosted.org/packages/d9/83/b2cfe8e76ff5c1c77f8a53da3d5de62d04b5ebf7cf913e37f8bca43b5d07/librt-0.7.8-cp313-cp313-win32.whl", hash = "sha256:b09c52ed43a461994716082ee7d87618096851319bf695d57ec123f2ab708951", size = 44126, upload-time = "2026-01-14T12:55:31.44Z" }, { url = "https://files.pythonhosted.org/packages/a9/0b/c59d45de56a51bd2d3a401fc63449c0ac163e4ef7f523ea8b0c0dee86ec5/librt-0.7.8-cp313-cp313-win_amd64.whl", hash = "sha256:f8f4a901a3fa28969d6e4519deceab56c55a09d691ea7b12ca830e2fa3461e34", size = 50262, upload-time = "2026-01-14T12:55:33.01Z" }, { url = "https://files.pythonhosted.org/packages/fc/b9/973455cec0a1ec592395250c474164c4a58ebf3e0651ee920fef1a2623f1/librt-0.7.8-cp313-cp313-win_arm64.whl", hash = "sha256:43d4e71b50763fcdcf64725ac680d8cfa1706c928b844794a7aa0fa9ac8e5f09", size = 43600, upload-time = "2026-01-14T12:55:34.054Z" }, { url = "https://files.pythonhosted.org/packages/1a/73/fa8814c6ce2d49c3827829cadaa1589b0bf4391660bd4510899393a23ebc/librt-0.7.8-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:be927c3c94c74b05128089a955fba86501c3b544d1d300282cc1b4bd370cb418", size = 57049, upload-time = "2026-01-14T12:55:35.056Z" }, { url = "https://files.pythonhosted.org/packages/53/fe/f6c70956da23ea235fd2e3cc16f4f0b4ebdfd72252b02d1164dd58b4e6c3/librt-0.7.8-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:7b0803e9008c62a7ef79058233db7ff6f37a9933b8f2573c05b07ddafa226611", size = 58689, upload-time = "2026-01-14T12:55:36.078Z" }, { url = "https://files.pythonhosted.org/packages/1f/4d/7a2481444ac5fba63050d9abe823e6bc16896f575bfc9c1e5068d516cdce/librt-0.7.8-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:79feb4d00b2a4e0e05c9c56df707934f41fcb5fe53fd9efb7549068d0495b758", size = 166808, upload-time = "2026-01-14T12:55:37.595Z" }, { url = "https://files.pythonhosted.org/packages/ac/3c/10901d9e18639f8953f57c8986796cfbf4c1c514844a41c9197cf87cb707/librt-0.7.8-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b9122094e3f24aa759c38f46bd8863433820654927370250f460ae75488b66ea", size = 175614, upload-time = "2026-01-14T12:55:38.756Z" }, { url = "https://files.pythonhosted.org/packages/db/01/5cbdde0951a5090a80e5ba44e6357d375048123c572a23eecfb9326993a7/librt-0.7.8-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7e03bea66af33c95ce3addf87a9bf1fcad8d33e757bc479957ddbc0e4f7207ac", size = 189955, upload-time = "2026-01-14T12:55:39.939Z" }, { url = "https://files.pythonhosted.org/packages/6a/b4/e80528d2f4b7eaf1d437fcbd6fc6ba4cbeb3e2a0cb9ed5a79f47c7318706/librt-0.7.8-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f1ade7f31675db00b514b98f9ab9a7698c7282dad4be7492589109471852d398", size = 189370, upload-time = "2026-01-14T12:55:41.057Z" }, { url = "https://files.pythonhosted.org/packages/c1/ab/938368f8ce31a9787ecd4becb1e795954782e4312095daf8fd22420227c8/librt-0.7.8-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:a14229ac62adcf1b90a15992f1ab9c69ae8b99ffb23cb64a90878a6e8a2f5b81", size = 183224, upload-time = "2026-01-14T12:55:42.328Z" }, { url = "https://files.pythonhosted.org/packages/3c/10/559c310e7a6e4014ac44867d359ef8238465fb499e7eb31b6bfe3e3f86f5/librt-0.7.8-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5bcaaf624fd24e6a0cb14beac37677f90793a96864c67c064a91458611446e83", size = 203541, upload-time = "2026-01-14T12:55:43.501Z" }, { url = "https://files.pythonhosted.org/packages/f8/db/a0db7acdb6290c215f343835c6efda5b491bb05c3ddc675af558f50fdba3/librt-0.7.8-cp314-cp314-win32.whl", hash = "sha256:7aa7d5457b6c542ecaed79cec4ad98534373c9757383973e638ccced0f11f46d", size = 40657, upload-time = "2026-01-14T12:55:44.668Z" }, { url = "https://files.pythonhosted.org/packages/72/e0/4f9bdc2a98a798511e81edcd6b54fe82767a715e05d1921115ac70717f6f/librt-0.7.8-cp314-cp314-win_amd64.whl", hash = "sha256:3d1322800771bee4a91f3b4bd4e49abc7d35e65166821086e5afd1e6c0d9be44", size = 46835, upload-time = "2026-01-14T12:55:45.655Z" }, { url = "https://files.pythonhosted.org/packages/f9/3d/59c6402e3dec2719655a41ad027a7371f8e2334aa794ed11533ad5f34969/librt-0.7.8-cp314-cp314-win_arm64.whl", hash = "sha256:5363427bc6a8c3b1719f8f3845ea53553d301382928a86e8fab7984426949bce", size = 39885, upload-time = "2026-01-14T12:55:47.138Z" }, { url = "https://files.pythonhosted.org/packages/4e/9c/2481d80950b83085fb14ba3c595db56330d21bbc7d88a19f20165f3538db/librt-0.7.8-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:ca916919793a77e4a98d4a1701e345d337ce53be4a16620f063191f7322ac80f", size = 59161, upload-time = "2026-01-14T12:55:48.45Z" }, { url = "https://files.pythonhosted.org/packages/96/79/108df2cfc4e672336765d54e3ff887294c1cc36ea4335c73588875775527/librt-0.7.8-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:54feb7b4f2f6706bb82325e836a01be805770443e2400f706e824e91f6441dde", size = 61008, upload-time = "2026-01-14T12:55:49.527Z" }, { url = "https://files.pythonhosted.org/packages/46/f2/30179898f9994a5637459d6e169b6abdc982012c0a4b2d4c26f50c06f911/librt-0.7.8-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:39a4c76fee41007070f872b648cc2f711f9abf9a13d0c7162478043377b52c8e", size = 187199, upload-time = "2026-01-14T12:55:50.587Z" }, { url = "https://files.pythonhosted.org/packages/b4/da/f7563db55cebdc884f518ba3791ad033becc25ff68eb70902b1747dc0d70/librt-0.7.8-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ac9c8a458245c7de80bc1b9765b177055efff5803f08e548dd4bb9ab9a8d789b", size = 198317, upload-time = "2026-01-14T12:55:51.991Z" }, { url = "https://files.pythonhosted.org/packages/b3/6c/4289acf076ad371471fa86718c30ae353e690d3de6167f7db36f429272f1/librt-0.7.8-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:95b67aa7eff150f075fda09d11f6bfb26edffd300f6ab1666759547581e8f666", size = 210334, upload-time = "2026-01-14T12:55:53.682Z" }, { url = "https://files.pythonhosted.org/packages/4a/7f/377521ac25b78ac0a5ff44127a0360ee6d5ddd3ce7327949876a30533daa/librt-0.7.8-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:535929b6eff670c593c34ff435d5440c3096f20fa72d63444608a5aef64dd581", size = 211031, upload-time = "2026-01-14T12:55:54.827Z" }, { url = "https://files.pythonhosted.org/packages/c5/b1/e1e96c3e20b23d00cf90f4aad48f0deb4cdfec2f0ed8380d0d85acf98bbf/librt-0.7.8-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:63937bd0f4d1cb56653dc7ae900d6c52c41f0015e25aaf9902481ee79943b33a", size = 204581, upload-time = "2026-01-14T12:55:56.811Z" }, { url = "https://files.pythonhosted.org/packages/43/71/0f5d010e92ed9747e14bef35e91b6580533510f1e36a8a09eb79ee70b2f0/librt-0.7.8-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cf243da9e42d914036fd362ac3fa77d80a41cadcd11ad789b1b5eec4daaf67ca", size = 224731, upload-time = "2026-01-14T12:55:58.175Z" }, { url = "https://files.pythonhosted.org/packages/22/f0/07fb6ab5c39a4ca9af3e37554f9d42f25c464829254d72e4ebbd81da351c/librt-0.7.8-cp314-cp314t-win32.whl", hash = "sha256:171ca3a0a06c643bd0a2f62a8944e1902c94aa8e5da4db1ea9a8daf872685365", size = 41173, upload-time = "2026-01-14T12:55:59.315Z" }, { url = "https://files.pythonhosted.org/packages/24/d4/7e4be20993dc6a782639625bd2f97f3c66125c7aa80c82426956811cfccf/librt-0.7.8-cp314-cp314t-win_amd64.whl", hash = "sha256:445b7304145e24c60288a2f172b5ce2ca35c0f81605f5299f3fa567e189d2e32", size = 47668, upload-time = "2026-01-14T12:56:00.261Z" }, { url = "https://files.pythonhosted.org/packages/fc/85/69f92b2a7b3c0f88ffe107c86b952b397004b5b8ea5a81da3d9c04c04422/librt-0.7.8-cp314-cp314t-win_arm64.whl", hash = "sha256:8766ece9de08527deabcd7cb1b4f1a967a385d26e33e536d6d8913db6ef74f06", size = 40550, upload-time = "2026-01-14T12:56:01.542Z" }, ] [[package]] name = "mypy" version = "1.19.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "librt", marker = "platform_python_implementation != 'PyPy'" }, { name = "mypy-extensions" }, { name = "pathspec" }, { name = "tomli", marker = "python_full_version < '3.11'" }, { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/f5/db/4efed9504bc01309ab9c2da7e352cc223569f05478012b5d9ece38fd44d2/mypy-1.19.1.tar.gz", hash = "sha256:19d88bb05303fe63f71dd2c6270daca27cb9401c4ca8255fe50d1d920e0eb9ba", size = 3582404, upload-time = "2025-12-15T05:03:48.42Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/2f/63/e499890d8e39b1ff2df4c0c6ce5d371b6844ee22b8250687a99fd2f657a8/mypy-1.19.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:5f05aa3d375b385734388e844bc01733bd33c644ab48e9684faa54e5389775ec", size = 13101333, upload-time = "2025-12-15T05:03:03.28Z" }, { url = "https://files.pythonhosted.org/packages/72/4b/095626fc136fba96effc4fd4a82b41d688ab92124f8c4f7564bffe5cf1b0/mypy-1.19.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:022ea7279374af1a5d78dfcab853fe6a536eebfda4b59deab53cd21f6cd9f00b", size = 12164102, upload-time = "2025-12-15T05:02:33.611Z" }, { url = "https://files.pythonhosted.org/packages/0c/5b/952928dd081bf88a83a5ccd49aaecfcd18fd0d2710c7ff07b8fb6f7032b9/mypy-1.19.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee4c11e460685c3e0c64a4c5de82ae143622410950d6be863303a1c4ba0e36d6", size = 12765799, upload-time = "2025-12-15T05:03:28.44Z" }, { url = "https://files.pythonhosted.org/packages/2a/0d/93c2e4a287f74ef11a66fb6d49c7a9f05e47b0a4399040e6719b57f500d2/mypy-1.19.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:de759aafbae8763283b2ee5869c7255391fbc4de3ff171f8f030b5ec48381b74", size = 13522149, upload-time = "2025-12-15T05:02:36.011Z" }, { url = "https://files.pythonhosted.org/packages/7b/0e/33a294b56aaad2b338d203e3a1d8b453637ac36cb278b45005e0901cf148/mypy-1.19.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:ab43590f9cd5108f41aacf9fca31841142c786827a74ab7cc8a2eacb634e09a1", size = 13810105, upload-time = "2025-12-15T05:02:40.327Z" }, { url = "https://files.pythonhosted.org/packages/0e/fd/3e82603a0cb66b67c5e7abababce6bf1a929ddf67bf445e652684af5c5a0/mypy-1.19.1-cp310-cp310-win_amd64.whl", hash = "sha256:2899753e2f61e571b3971747e302d5f420c3fd09650e1951e99f823bc3089dac", size = 10057200, upload-time = "2025-12-15T05:02:51.012Z" }, { url = "https://files.pythonhosted.org/packages/ef/47/6b3ebabd5474d9cdc170d1342fbf9dddc1b0ec13ec90bf9004ee6f391c31/mypy-1.19.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d8dfc6ab58ca7dda47d9237349157500468e404b17213d44fc1cb77bce532288", size = 13028539, upload-time = "2025-12-15T05:03:44.129Z" }, { url = "https://files.pythonhosted.org/packages/5c/a6/ac7c7a88a3c9c54334f53a941b765e6ec6c4ebd65d3fe8cdcfbe0d0fd7db/mypy-1.19.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e3f276d8493c3c97930e354b2595a44a21348b320d859fb4a2b9f66da9ed27ab", size = 12083163, upload-time = "2025-12-15T05:03:37.679Z" }, { url = "https://files.pythonhosted.org/packages/67/af/3afa9cf880aa4a2c803798ac24f1d11ef72a0c8079689fac5cfd815e2830/mypy-1.19.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2abb24cf3f17864770d18d673c85235ba52456b36a06b6afc1e07c1fdcd3d0e6", size = 12687629, upload-time = "2025-12-15T05:02:31.526Z" }, { url = "https://files.pythonhosted.org/packages/2d/46/20f8a7114a56484ab268b0ab372461cb3a8f7deed31ea96b83a4e4cfcfca/mypy-1.19.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a009ffa5a621762d0c926a078c2d639104becab69e79538a494bcccb62cc0331", size = 13436933, upload-time = "2025-12-15T05:03:15.606Z" }, { url = "https://files.pythonhosted.org/packages/5b/f8/33b291ea85050a21f15da910002460f1f445f8007adb29230f0adea279cb/mypy-1.19.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f7cee03c9a2e2ee26ec07479f38ea9c884e301d42c6d43a19d20fb014e3ba925", size = 13661754, upload-time = "2025-12-15T05:02:26.731Z" }, { url = "https://files.pythonhosted.org/packages/fd/a3/47cbd4e85bec4335a9cd80cf67dbc02be21b5d4c9c23ad6b95d6c5196bac/mypy-1.19.1-cp311-cp311-win_amd64.whl", hash = "sha256:4b84a7a18f41e167f7995200a1d07a4a6810e89d29859df936f1c3923d263042", size = 10055772, upload-time = "2025-12-15T05:03:26.179Z" }, { url = "https://files.pythonhosted.org/packages/06/8a/19bfae96f6615aa8a0604915512e0289b1fad33d5909bf7244f02935d33a/mypy-1.19.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a8174a03289288c1f6c46d55cef02379b478bfbc8e358e02047487cad44c6ca1", size = 13206053, upload-time = "2025-12-15T05:03:46.622Z" }, { url = "https://files.pythonhosted.org/packages/a5/34/3e63879ab041602154ba2a9f99817bb0c85c4df19a23a1443c8986e4d565/mypy-1.19.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ffcebe56eb09ff0c0885e750036a095e23793ba6c2e894e7e63f6d89ad51f22e", size = 12219134, upload-time = "2025-12-15T05:03:24.367Z" }, { url = "https://files.pythonhosted.org/packages/89/cc/2db6f0e95366b630364e09845672dbee0cbf0bbe753a204b29a944967cd9/mypy-1.19.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b64d987153888790bcdb03a6473d321820597ab8dd9243b27a92153c4fa50fd2", size = 12731616, upload-time = "2025-12-15T05:02:44.725Z" }, { url = "https://files.pythonhosted.org/packages/00/be/dd56c1fd4807bc1eba1cf18b2a850d0de7bacb55e158755eb79f77c41f8e/mypy-1.19.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c35d298c2c4bba75feb2195655dfea8124d855dfd7343bf8b8c055421eaf0cf8", size = 13620847, upload-time = "2025-12-15T05:03:39.633Z" }, { url = "https://files.pythonhosted.org/packages/6d/42/332951aae42b79329f743bf1da088cd75d8d4d9acc18fbcbd84f26c1af4e/mypy-1.19.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:34c81968774648ab5ac09c29a375fdede03ba253f8f8287847bd480782f73a6a", size = 13834976, upload-time = "2025-12-15T05:03:08.786Z" }, { url = "https://files.pythonhosted.org/packages/6f/63/e7493e5f90e1e085c562bb06e2eb32cae27c5057b9653348d38b47daaecc/mypy-1.19.1-cp312-cp312-win_amd64.whl", hash = "sha256:b10e7c2cd7870ba4ad9b2d8a6102eb5ffc1f16ca35e3de6bfa390c1113029d13", size = 10118104, upload-time = "2025-12-15T05:03:10.834Z" }, { url = "https://files.pythonhosted.org/packages/de/9f/a6abae693f7a0c697dbb435aac52e958dc8da44e92e08ba88d2e42326176/mypy-1.19.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e3157c7594ff2ef1634ee058aafc56a82db665c9438fd41b390f3bde1ab12250", size = 13201927, upload-time = "2025-12-15T05:02:29.138Z" }, { url = "https://files.pythonhosted.org/packages/9a/a4/45c35ccf6e1c65afc23a069f50e2c66f46bd3798cbe0d680c12d12935caa/mypy-1.19.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bdb12f69bcc02700c2b47e070238f42cb87f18c0bc1fc4cdb4fb2bc5fd7a3b8b", size = 12206730, upload-time = "2025-12-15T05:03:01.325Z" }, { url = "https://files.pythonhosted.org/packages/05/bb/cdcf89678e26b187650512620eec8368fded4cfd99cfcb431e4cdfd19dec/mypy-1.19.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f859fb09d9583a985be9a493d5cfc5515b56b08f7447759a0c5deaf68d80506e", size = 12724581, upload-time = "2025-12-15T05:03:20.087Z" }, { url = "https://files.pythonhosted.org/packages/d1/32/dd260d52babf67bad8e6770f8e1102021877ce0edea106e72df5626bb0ec/mypy-1.19.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c9a6538e0415310aad77cb94004ca6482330fece18036b5f360b62c45814c4ef", size = 13616252, upload-time = "2025-12-15T05:02:49.036Z" }, { url = "https://files.pythonhosted.org/packages/71/d0/5e60a9d2e3bd48432ae2b454b7ef2b62a960ab51292b1eda2a95edd78198/mypy-1.19.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:da4869fc5e7f62a88f3fe0b5c919d1d9f7ea3cef92d3689de2823fd27e40aa75", size = 13840848, upload-time = "2025-12-15T05:02:55.95Z" }, { url = "https://files.pythonhosted.org/packages/98/76/d32051fa65ecf6cc8c6610956473abdc9b4c43301107476ac03559507843/mypy-1.19.1-cp313-cp313-win_amd64.whl", hash = "sha256:016f2246209095e8eda7538944daa1d60e1e8134d98983b9fc1e92c1fc0cb8dd", size = 10135510, upload-time = "2025-12-15T05:02:58.438Z" }, { url = "https://files.pythonhosted.org/packages/de/eb/b83e75f4c820c4247a58580ef86fcd35165028f191e7e1ba57128c52782d/mypy-1.19.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:06e6170bd5836770e8104c8fdd58e5e725cfeb309f0a6c681a811f557e97eac1", size = 13199744, upload-time = "2025-12-15T05:03:30.823Z" }, { url = "https://files.pythonhosted.org/packages/94/28/52785ab7bfa165f87fcbb61547a93f98bb20e7f82f90f165a1f69bce7b3d/mypy-1.19.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:804bd67b8054a85447c8954215a906d6eff9cabeabe493fb6334b24f4bfff718", size = 12215815, upload-time = "2025-12-15T05:02:42.323Z" }, { url = "https://files.pythonhosted.org/packages/0a/c6/bdd60774a0dbfb05122e3e925f2e9e846c009e479dcec4821dad881f5b52/mypy-1.19.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:21761006a7f497cb0d4de3d8ef4ca70532256688b0523eee02baf9eec895e27b", size = 12740047, upload-time = "2025-12-15T05:03:33.168Z" }, { url = "https://files.pythonhosted.org/packages/32/2a/66ba933fe6c76bd40d1fe916a83f04fed253152f451a877520b3c4a5e41e/mypy-1.19.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:28902ee51f12e0f19e1e16fbe2f8f06b6637f482c459dd393efddd0ec7f82045", size = 13601998, upload-time = "2025-12-15T05:03:13.056Z" }, { url = "https://files.pythonhosted.org/packages/e3/da/5055c63e377c5c2418760411fd6a63ee2b96cf95397259038756c042574f/mypy-1.19.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:481daf36a4c443332e2ae9c137dfee878fcea781a2e3f895d54bd3002a900957", size = 13807476, upload-time = "2025-12-15T05:03:17.977Z" }, { url = "https://files.pythonhosted.org/packages/cd/09/4ebd873390a063176f06b0dbf1f7783dd87bd120eae7727fa4ae4179b685/mypy-1.19.1-cp314-cp314-win_amd64.whl", hash = "sha256:8bb5c6f6d043655e055be9b542aa5f3bdd30e4f3589163e85f93f3640060509f", size = 10281872, upload-time = "2025-12-15T05:03:05.549Z" }, { url = "https://files.pythonhosted.org/packages/8d/f4/4ce9a05ce5ded1de3ec1c1d96cf9f9504a04e54ce0ed55cfa38619a32b8d/mypy-1.19.1-py3-none-any.whl", hash = "sha256:f1235f5ea01b7db5468d53ece6aaddf1ad0b88d9e7462b86ef96fe04995d7247", size = 2471239, upload-time = "2025-12-15T05:03:07.248Z" }, ] [[package]] name = "mypy-extensions" version = "1.1.0" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/a2/6e/371856a3fb9d31ca8dac321cda606860fa4548858c0cc45d9d1d4ca2628b/mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558", size = 6343, upload-time = "2025-04-22T14:54:24.164Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" }, ] [[package]] name = "nodeenv" version = "1.10.0" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/24/bf/d1bda4f6168e0b2e9e5958945e01910052158313224ada5ce1fb2e1113b8/nodeenv-1.10.0.tar.gz", hash = "sha256:996c191ad80897d076bdfba80a41994c2b47c68e224c542b48feba42ba00f8bb", size = 55611, upload-time = "2025-12-20T14:08:54.006Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/88/b2/d0896bdcdc8d28a7fc5717c305f1a861c26e18c05047949fb371034d98bd/nodeenv-1.10.0-py2.py3-none-any.whl", hash = "sha256:5bb13e3eed2923615535339b3c620e76779af4cb4c6a90deccc9e36b274d3827", size = 23438, upload-time = "2025-12-20T14:08:52.782Z" }, ] [[package]] name = "numpy" version = "1.26.4" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/65/6e/09db70a523a96d25e115e71cc56a6f9031e7b8cd166c1ac8438307c14058/numpy-1.26.4.tar.gz", hash = "sha256:2a02aba9ed12e4ac4eb3ea9421c420301a0c6460d9830d74a9df87efa4912010", size = 15786129, upload-time = "2024-02-06T00:26:44.495Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/a7/94/ace0fdea5241a27d13543ee117cbc65868e82213fb31a8eb7fe9ff23f313/numpy-1.26.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:9ff0f4f29c51e2803569d7a51c2304de5554655a60c5d776e35b4a41413830d0", size = 20631468, upload-time = "2024-02-05T23:48:01.194Z" }, { url = "https://files.pythonhosted.org/packages/20/f7/b24208eba89f9d1b58c1668bc6c8c4fd472b20c45573cb767f59d49fb0f6/numpy-1.26.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2e4ee3380d6de9c9ec04745830fd9e2eccb3e6cf790d39d7b98ffd19b0dd754a", size = 13966411, upload-time = "2024-02-05T23:48:29.038Z" }, { url = "https://files.pythonhosted.org/packages/fc/a5/4beee6488160798683eed5bdb7eead455892c3b4e1f78d79d8d3f3b084ac/numpy-1.26.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d209d8969599b27ad20994c8e41936ee0964e6da07478d6c35016bc386b66ad4", size = 14219016, upload-time = "2024-02-05T23:48:54.098Z" }, { url = "https://files.pythonhosted.org/packages/4b/d7/ecf66c1cd12dc28b4040b15ab4d17b773b87fa9d29ca16125de01adb36cd/numpy-1.26.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ffa75af20b44f8dba823498024771d5ac50620e6915abac414251bd971b4529f", size = 18240889, upload-time = "2024-02-05T23:49:25.361Z" }, { url = "https://files.pythonhosted.org/packages/24/03/6f229fe3187546435c4f6f89f6d26c129d4f5bed40552899fcf1f0bf9e50/numpy-1.26.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:62b8e4b1e28009ef2846b4c7852046736bab361f7aeadeb6a5b89ebec3c7055a", size = 13876746, upload-time = "2024-02-05T23:49:51.983Z" }, { url = "https://files.pythonhosted.org/packages/39/fe/39ada9b094f01f5a35486577c848fe274e374bbf8d8f472e1423a0bbd26d/numpy-1.26.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a4abb4f9001ad2858e7ac189089c42178fcce737e4169dc61321660f1a96c7d2", size = 18078620, upload-time = "2024-02-05T23:50:22.515Z" }, { url = "https://files.pythonhosted.org/packages/d5/ef/6ad11d51197aad206a9ad2286dc1aac6a378059e06e8cf22cd08ed4f20dc/numpy-1.26.4-cp310-cp310-win32.whl", hash = "sha256:bfe25acf8b437eb2a8b2d49d443800a5f18508cd811fea3181723922a8a82b07", size = 5972659, upload-time = "2024-02-05T23:50:35.834Z" }, { url = "https://files.pythonhosted.org/packages/19/77/538f202862b9183f54108557bfda67e17603fc560c384559e769321c9d92/numpy-1.26.4-cp310-cp310-win_amd64.whl", hash = "sha256:b97fe8060236edf3662adfc2c633f56a08ae30560c56310562cb4f95500022d5", size = 15808905, upload-time = "2024-02-05T23:51:03.701Z" }, { url = "https://files.pythonhosted.org/packages/11/57/baae43d14fe163fa0e4c47f307b6b2511ab8d7d30177c491960504252053/numpy-1.26.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4c66707fabe114439db9068ee468c26bbdf909cac0fb58686a42a24de1760c71", size = 20630554, upload-time = "2024-02-05T23:51:50.149Z" }, { url = "https://files.pythonhosted.org/packages/1a/2e/151484f49fd03944c4a3ad9c418ed193cfd02724e138ac8a9505d056c582/numpy-1.26.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:edd8b5fe47dab091176d21bb6de568acdd906d1887a4584a15a9a96a1dca06ef", size = 13997127, upload-time = "2024-02-05T23:52:15.314Z" }, { url = "https://files.pythonhosted.org/packages/79/ae/7e5b85136806f9dadf4878bf73cf223fe5c2636818ba3ab1c585d0403164/numpy-1.26.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7ab55401287bfec946ced39700c053796e7cc0e3acbef09993a9ad2adba6ca6e", size = 14222994, upload-time = "2024-02-05T23:52:47.569Z" }, { url = "https://files.pythonhosted.org/packages/3a/d0/edc009c27b406c4f9cbc79274d6e46d634d139075492ad055e3d68445925/numpy-1.26.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:666dbfb6ec68962c033a450943ded891bed2d54e6755e35e5835d63f4f6931d5", size = 18252005, upload-time = "2024-02-05T23:53:15.637Z" }, { url = "https://files.pythonhosted.org/packages/09/bf/2b1aaf8f525f2923ff6cfcf134ae5e750e279ac65ebf386c75a0cf6da06a/numpy-1.26.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:96ff0b2ad353d8f990b63294c8986f1ec3cb19d749234014f4e7eb0112ceba5a", size = 13885297, upload-time = "2024-02-05T23:53:42.16Z" }, { url = "https://files.pythonhosted.org/packages/df/a0/4e0f14d847cfc2a633a1c8621d00724f3206cfeddeb66d35698c4e2cf3d2/numpy-1.26.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:60dedbb91afcbfdc9bc0b1f3f402804070deed7392c23eb7a7f07fa857868e8a", size = 18093567, upload-time = "2024-02-05T23:54:11.696Z" }, { url = "https://files.pythonhosted.org/packages/d2/b7/a734c733286e10a7f1a8ad1ae8c90f2d33bf604a96548e0a4a3a6739b468/numpy-1.26.4-cp311-cp311-win32.whl", hash = "sha256:1af303d6b2210eb850fcf03064d364652b7120803a0b872f5211f5234b399f20", size = 5968812, upload-time = "2024-02-05T23:54:26.453Z" }, { url = "https://files.pythonhosted.org/packages/3f/6b/5610004206cf7f8e7ad91c5a85a8c71b2f2f8051a0c0c4d5916b76d6cbb2/numpy-1.26.4-cp311-cp311-win_amd64.whl", hash = "sha256:cd25bcecc4974d09257ffcd1f098ee778f7834c3ad767fe5db785be9a4aa9cb2", size = 15811913, upload-time = "2024-02-05T23:54:53.933Z" }, { url = "https://files.pythonhosted.org/packages/95/12/8f2020a8e8b8383ac0177dc9570aad031a3beb12e38847f7129bacd96228/numpy-1.26.4-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b3ce300f3644fb06443ee2222c2201dd3a89ea6040541412b8fa189341847218", size = 20335901, upload-time = "2024-02-05T23:55:32.801Z" }, { url = "https://files.pythonhosted.org/packages/75/5b/ca6c8bd14007e5ca171c7c03102d17b4f4e0ceb53957e8c44343a9546dcc/numpy-1.26.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:03a8c78d01d9781b28a6989f6fa1bb2c4f2d51201cf99d3dd875df6fbd96b23b", size = 13685868, upload-time = "2024-02-05T23:55:56.28Z" }, { url = "https://files.pythonhosted.org/packages/79/f8/97f10e6755e2a7d027ca783f63044d5b1bc1ae7acb12afe6a9b4286eac17/numpy-1.26.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9fad7dcb1aac3c7f0584a5a8133e3a43eeb2fe127f47e3632d43d677c66c102b", size = 13925109, upload-time = "2024-02-05T23:56:20.368Z" }, { url = "https://files.pythonhosted.org/packages/0f/50/de23fde84e45f5c4fda2488c759b69990fd4512387a8632860f3ac9cd225/numpy-1.26.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:675d61ffbfa78604709862923189bad94014bef562cc35cf61d3a07bba02a7ed", size = 17950613, upload-time = "2024-02-05T23:56:56.054Z" }, { url = "https://files.pythonhosted.org/packages/4c/0c/9c603826b6465e82591e05ca230dfc13376da512b25ccd0894709b054ed0/numpy-1.26.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:ab47dbe5cc8210f55aa58e4805fe224dac469cde56b9f731a4c098b91917159a", size = 13572172, upload-time = "2024-02-05T23:57:21.56Z" }, { url = "https://files.pythonhosted.org/packages/76/8c/2ba3902e1a0fc1c74962ea9bb33a534bb05984ad7ff9515bf8d07527cadd/numpy-1.26.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:1dda2e7b4ec9dd512f84935c5f126c8bd8b9f2fc001e9f54af255e8c5f16b0e0", size = 17786643, upload-time = "2024-02-05T23:57:56.585Z" }, { url = "https://files.pythonhosted.org/packages/28/4a/46d9e65106879492374999e76eb85f87b15328e06bd1550668f79f7b18c6/numpy-1.26.4-cp312-cp312-win32.whl", hash = "sha256:50193e430acfc1346175fcbdaa28ffec49947a06918b7b92130744e81e640110", size = 5677803, upload-time = "2024-02-05T23:58:08.963Z" }, { url = "https://files.pythonhosted.org/packages/16/2e/86f24451c2d530c88daf997cb8d6ac622c1d40d19f5a031ed68a4b73a374/numpy-1.26.4-cp312-cp312-win_amd64.whl", hash = "sha256:08beddf13648eb95f8d867350f6a018a4be2e5ad54c8d8caed89ebca558b2818", size = 15517754, upload-time = "2024-02-05T23:58:36.364Z" }, ] [[package]] name = "pathspec" version = "1.0.4" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/fa/36/e27608899f9b8d4dff0617b2d9ab17ca5608956ca44461ac14ac48b44015/pathspec-1.0.4.tar.gz", hash = "sha256:0210e2ae8a21a9137c0d470578cb0e595af87edaa6ebf12ff176f14a02e0e645", size = 131200, upload-time = "2026-01-27T03:59:46.938Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/ef/3c/2c197d226f9ea224a9ab8d197933f9da0ae0aac5b6e0f884e2b8d9c8e9f7/pathspec-1.0.4-py3-none-any.whl", hash = "sha256:fb6ae2fd4e7c921a165808a552060e722767cfa526f99ca5156ed2ce45a5c723", size = 55206, upload-time = "2026-01-27T03:59:45.137Z" }, ] [[package]] name = "pip" version = "26.0" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/44/c2/65686a7783a7c27a329706207147e82f23c41221ee9ae33128fc331670a0/pip-26.0.tar.gz", hash = "sha256:3ce220a0a17915972fbf1ab451baae1521c4539e778b28127efa79b974aff0fa", size = 1812654, upload-time = "2026-01-31T01:40:54.361Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/69/00/5ac7aa77688ec4d34148b423d34dc0c9bc4febe0d872a9a1ad9860b2f6f1/pip-26.0-py3-none-any.whl", hash = "sha256:98436feffb9e31bc9339cf369fd55d3331b1580b6a6f1173bacacddcf9c34754", size = 1787564, upload-time = "2026-01-31T01:40:52.252Z" }, ] [[package]] name = "platformdirs" version = "4.9.6" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/9f/4a/0883b8e3802965322523f0b200ecf33d31f10991d0401162f4b23c698b42/platformdirs-4.9.6.tar.gz", hash = "sha256:3bfa75b0ad0db84096ae777218481852c0ebc6c727b3168c1b9e0118e458cf0a", size = 29400, upload-time = "2026-04-09T00:04:10.812Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/75/a6/a0a304dc33b49145b21f4808d763822111e67d1c3a32b524a1baf947b6e1/platformdirs-4.9.6-py3-none-any.whl", hash = "sha256:e61adb1d5e5cb3441b4b7710bea7e4c12250ca49439228cc1021c00dcfac0917", size = 21348, upload-time = "2026-04-09T00:04:09.463Z" }, ] [[package]] name = "pre-commit" version = "4.5.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "cfgv" }, { name = "identify" }, { name = "nodeenv" }, { name = "pyyaml" }, { name = "virtualenv" }, ] sdist = { url = "https://files.pythonhosted.org/packages/40/f1/6d86a29246dfd2e9b6237f0b5823717f60cad94d47ddc26afa916d21f525/pre_commit-4.5.1.tar.gz", hash = "sha256:eb545fcff725875197837263e977ea257a402056661f09dae08e4b149b030a61", size = 198232, upload-time = "2025-12-16T21:14:33.552Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/5d/19/fd3ef348460c80af7bb4669ea7926651d1f95c23ff2df18b9d24bab4f3fa/pre_commit-4.5.1-py2.py3-none-any.whl", hash = "sha256:3b3afd891e97337708c1674210f8eba659b52a38ea5f822ff142d10786221f77", size = 226437, upload-time = "2025-12-16T21:14:32.409Z" }, ] [[package]] name = "pybind11-stubgen" version = "3.0.0" source = { editable = "." } [package.dev-dependencies] dev = [ { name = "cmeel" }, { name = "cmeel-eigen" }, { name = "mypy" }, { name = "numpy" }, { name = "pip" }, { name = "pre-commit" }, { name = "scipy", version = "1.15.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, { name = "scipy", version = "1.17.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, { name = "typing-extensions" }, ] [package.metadata] [package.metadata.requires-dev] dev = [ { name = "cmeel", specifier = "==0.59.0" }, { name = "cmeel-eigen", specifier = "==3.4.0.2" }, { name = "mypy", specifier = ">=1.19.1" }, { name = "numpy", specifier = "~=1.20" }, { name = "pip" }, { name = "pre-commit", specifier = ">=4,<5" }, { name = "scipy", specifier = "~=1.0" }, { name = "typing-extensions", specifier = ">=4,<5" }, ] [[package]] name = "python-discovery" version = "1.2.2" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "filelock" }, { name = "platformdirs" }, ] sdist = { url = "https://files.pythonhosted.org/packages/de/ef/3bae0e537cfe91e8431efcba4434463d2c5a65f5a89edd47c6cf2f03c55f/python_discovery-1.2.2.tar.gz", hash = "sha256:876e9c57139eb757cb5878cbdd9ae5379e5d96266c99ef731119e04fffe533bb", size = 58872, upload-time = "2026-04-07T17:28:49.249Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/d8/db/795879cc3ddfe338599bddea6388cc5100b088db0a4caf6e6c1af1c27e04/python_discovery-1.2.2-py3-none-any.whl", hash = "sha256:e1ae95d9af875e78f15e19aed0c6137ab1bb49c200f21f5061786490c9585c7a", size = 31894, upload-time = "2026-04-07T17:28:48.09Z" }, ] [[package]] name = "pyyaml" version = "6.0.3" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/f4/a0/39350dd17dd6d6c6507025c0e53aef67a9293a6d37d3511f23ea510d5800/pyyaml-6.0.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b", size = 184227, upload-time = "2025-09-25T21:31:46.04Z" }, { url = "https://files.pythonhosted.org/packages/05/14/52d505b5c59ce73244f59c7a50ecf47093ce4765f116cdb98286a71eeca2/pyyaml-6.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956", size = 174019, upload-time = "2025-09-25T21:31:47.706Z" }, { url = "https://files.pythonhosted.org/packages/43/f7/0e6a5ae5599c838c696adb4e6330a59f463265bfa1e116cfd1fbb0abaaae/pyyaml-6.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8", size = 740646, upload-time = "2025-09-25T21:31:49.21Z" }, { url = "https://files.pythonhosted.org/packages/2f/3a/61b9db1d28f00f8fd0ae760459a5c4bf1b941baf714e207b6eb0657d2578/pyyaml-6.0.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198", size = 840793, upload-time = "2025-09-25T21:31:50.735Z" }, { url = "https://files.pythonhosted.org/packages/7a/1e/7acc4f0e74c4b3d9531e24739e0ab832a5edf40e64fbae1a9c01941cabd7/pyyaml-6.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b", size = 770293, upload-time = "2025-09-25T21:31:51.828Z" }, { url = "https://files.pythonhosted.org/packages/8b/ef/abd085f06853af0cd59fa5f913d61a8eab65d7639ff2a658d18a25d6a89d/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0", size = 732872, upload-time = "2025-09-25T21:31:53.282Z" }, { url = "https://files.pythonhosted.org/packages/1f/15/2bc9c8faf6450a8b3c9fc5448ed869c599c0a74ba2669772b1f3a0040180/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69", size = 758828, upload-time = "2025-09-25T21:31:54.807Z" }, { url = "https://files.pythonhosted.org/packages/a3/00/531e92e88c00f4333ce359e50c19b8d1de9fe8d581b1534e35ccfbc5f393/pyyaml-6.0.3-cp310-cp310-win32.whl", hash = "sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e", size = 142415, upload-time = "2025-09-25T21:31:55.885Z" }, { url = "https://files.pythonhosted.org/packages/2a/fa/926c003379b19fca39dd4634818b00dec6c62d87faf628d1394e137354d4/pyyaml-6.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c", size = 158561, upload-time = "2025-09-25T21:31:57.406Z" }, { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" }, { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" }, { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" }, { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" }, { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" }, { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" }, { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" }, { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" }, { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" }, { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" }, { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" }, { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" }, { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" }, { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" }, { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" }, { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" }, { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" }, { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" }, { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" }, { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" }, { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" }, { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" }, { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" }, { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" }, { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" }, { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" }, { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" }, { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" }, { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" }, { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" }, { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" }, { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" }, { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" }, { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" }, { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" }, { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" }, { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" }, { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" }, { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" }, { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" }, { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" }, { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" }, { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" }, { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" }, { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" }, { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" }, { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" }, ] [[package]] name = "scipy" version = "1.15.3" source = { registry = "https://pypi.org/simple" } resolution-markers = [ "python_full_version < '3.11'", ] dependencies = [ { name = "numpy" }, ] sdist = { url = "https://files.pythonhosted.org/packages/0f/37/6964b830433e654ec7485e45a00fc9a27cf868d622838f6b6d9c5ec0d532/scipy-1.15.3.tar.gz", hash = "sha256:eae3cf522bc7df64b42cad3925c876e1b0b6c35c1337c93e12c0f366f55b0eaf", size = 59419214, upload-time = "2025-05-08T16:13:05.955Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/78/2f/4966032c5f8cc7e6a60f1b2e0ad686293b9474b65246b0c642e3ef3badd0/scipy-1.15.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:a345928c86d535060c9c2b25e71e87c39ab2f22fc96e9636bd74d1dbf9de448c", size = 38702770, upload-time = "2025-05-08T16:04:20.849Z" }, { url = "https://files.pythonhosted.org/packages/a0/6e/0c3bf90fae0e910c274db43304ebe25a6b391327f3f10b5dcc638c090795/scipy-1.15.3-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:ad3432cb0f9ed87477a8d97f03b763fd1d57709f1bbde3c9369b1dff5503b253", size = 30094511, upload-time = "2025-05-08T16:04:27.103Z" }, { url = "https://files.pythonhosted.org/packages/ea/b1/4deb37252311c1acff7f101f6453f0440794f51b6eacb1aad4459a134081/scipy-1.15.3-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:aef683a9ae6eb00728a542b796f52a5477b78252edede72b8327a886ab63293f", size = 22368151, upload-time = "2025-05-08T16:04:31.731Z" }, { url = "https://files.pythonhosted.org/packages/38/7d/f457626e3cd3c29b3a49ca115a304cebb8cc6f31b04678f03b216899d3c6/scipy-1.15.3-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:1c832e1bd78dea67d5c16f786681b28dd695a8cb1fb90af2e27580d3d0967e92", size = 25121732, upload-time = "2025-05-08T16:04:36.596Z" }, { url = "https://files.pythonhosted.org/packages/db/0a/92b1de4a7adc7a15dcf5bddc6e191f6f29ee663b30511ce20467ef9b82e4/scipy-1.15.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:263961f658ce2165bbd7b99fa5135195c3a12d9bef045345016b8b50c315cb82", size = 35547617, upload-time = "2025-05-08T16:04:43.546Z" }, { url = "https://files.pythonhosted.org/packages/8e/6d/41991e503e51fc1134502694c5fa7a1671501a17ffa12716a4a9151af3df/scipy-1.15.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9e2abc762b0811e09a0d3258abee2d98e0c703eee49464ce0069590846f31d40", size = 37662964, upload-time = "2025-05-08T16:04:49.431Z" }, { url = "https://files.pythonhosted.org/packages/25/e1/3df8f83cb15f3500478c889be8fb18700813b95e9e087328230b98d547ff/scipy-1.15.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:ed7284b21a7a0c8f1b6e5977ac05396c0d008b89e05498c8b7e8f4a1423bba0e", size = 37238749, upload-time = "2025-05-08T16:04:55.215Z" }, { url = "https://files.pythonhosted.org/packages/93/3e/b3257cf446f2a3533ed7809757039016b74cd6f38271de91682aa844cfc5/scipy-1.15.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5380741e53df2c566f4d234b100a484b420af85deb39ea35a1cc1be84ff53a5c", size = 40022383, upload-time = "2025-05-08T16:05:01.914Z" }, { url = "https://files.pythonhosted.org/packages/d1/84/55bc4881973d3f79b479a5a2e2df61c8c9a04fcb986a213ac9c02cfb659b/scipy-1.15.3-cp310-cp310-win_amd64.whl", hash = "sha256:9d61e97b186a57350f6d6fd72640f9e99d5a4a2b8fbf4b9ee9a841eab327dc13", size = 41259201, upload-time = "2025-05-08T16:05:08.166Z" }, { url = "https://files.pythonhosted.org/packages/96/ab/5cc9f80f28f6a7dff646c5756e559823614a42b1939d86dd0ed550470210/scipy-1.15.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:993439ce220d25e3696d1b23b233dd010169b62f6456488567e830654ee37a6b", size = 38714255, upload-time = "2025-05-08T16:05:14.596Z" }, { url = "https://files.pythonhosted.org/packages/4a/4a/66ba30abe5ad1a3ad15bfb0b59d22174012e8056ff448cb1644deccbfed2/scipy-1.15.3-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:34716e281f181a02341ddeaad584205bd2fd3c242063bd3423d61ac259ca7eba", size = 30111035, upload-time = "2025-05-08T16:05:20.152Z" }, { url = "https://files.pythonhosted.org/packages/4b/fa/a7e5b95afd80d24313307f03624acc65801846fa75599034f8ceb9e2cbf6/scipy-1.15.3-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:3b0334816afb8b91dab859281b1b9786934392aa3d527cd847e41bb6f45bee65", size = 22384499, upload-time = "2025-05-08T16:05:24.494Z" }, { url = "https://files.pythonhosted.org/packages/17/99/f3aaddccf3588bb4aea70ba35328c204cadd89517a1612ecfda5b2dd9d7a/scipy-1.15.3-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:6db907c7368e3092e24919b5e31c76998b0ce1684d51a90943cb0ed1b4ffd6c1", size = 25152602, upload-time = "2025-05-08T16:05:29.313Z" }, { url = "https://files.pythonhosted.org/packages/56/c5/1032cdb565f146109212153339f9cb8b993701e9fe56b1c97699eee12586/scipy-1.15.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:721d6b4ef5dc82ca8968c25b111e307083d7ca9091bc38163fb89243e85e3889", size = 35503415, upload-time = "2025-05-08T16:05:34.699Z" }, { url = "https://files.pythonhosted.org/packages/bd/37/89f19c8c05505d0601ed5650156e50eb881ae3918786c8fd7262b4ee66d3/scipy-1.15.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:39cb9c62e471b1bb3750066ecc3a3f3052b37751c7c3dfd0fd7e48900ed52982", size = 37652622, upload-time = "2025-05-08T16:05:40.762Z" }, { url = "https://files.pythonhosted.org/packages/7e/31/be59513aa9695519b18e1851bb9e487de66f2d31f835201f1b42f5d4d475/scipy-1.15.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:795c46999bae845966368a3c013e0e00947932d68e235702b5c3f6ea799aa8c9", size = 37244796, upload-time = "2025-05-08T16:05:48.119Z" }, { url = "https://files.pythonhosted.org/packages/10/c0/4f5f3eeccc235632aab79b27a74a9130c6c35df358129f7ac8b29f562ac7/scipy-1.15.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:18aaacb735ab38b38db42cb01f6b92a2d0d4b6aabefeb07f02849e47f8fb3594", size = 40047684, upload-time = "2025-05-08T16:05:54.22Z" }, { url = "https://files.pythonhosted.org/packages/ab/a7/0ddaf514ce8a8714f6ed243a2b391b41dbb65251affe21ee3077ec45ea9a/scipy-1.15.3-cp311-cp311-win_amd64.whl", hash = "sha256:ae48a786a28412d744c62fd7816a4118ef97e5be0bee968ce8f0a2fba7acf3bb", size = 41246504, upload-time = "2025-05-08T16:06:00.437Z" }, { url = "https://files.pythonhosted.org/packages/37/4b/683aa044c4162e10ed7a7ea30527f2cbd92e6999c10a8ed8edb253836e9c/scipy-1.15.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6ac6310fdbfb7aa6612408bd2f07295bcbd3fda00d2d702178434751fe48e019", size = 38766735, upload-time = "2025-05-08T16:06:06.471Z" }, { url = "https://files.pythonhosted.org/packages/7b/7e/f30be3d03de07f25dc0ec926d1681fed5c732d759ac8f51079708c79e680/scipy-1.15.3-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:185cd3d6d05ca4b44a8f1595af87f9c372bb6acf9c808e99aa3e9aa03bd98cf6", size = 30173284, upload-time = "2025-05-08T16:06:11.686Z" }, { url = "https://files.pythonhosted.org/packages/07/9c/0ddb0d0abdabe0d181c1793db51f02cd59e4901da6f9f7848e1f96759f0d/scipy-1.15.3-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:05dc6abcd105e1a29f95eada46d4a3f251743cfd7d3ae8ddb4088047f24ea477", size = 22446958, upload-time = "2025-05-08T16:06:15.97Z" }, { url = "https://files.pythonhosted.org/packages/af/43/0bce905a965f36c58ff80d8bea33f1f9351b05fad4beaad4eae34699b7a1/scipy-1.15.3-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:06efcba926324df1696931a57a176c80848ccd67ce6ad020c810736bfd58eb1c", size = 25242454, upload-time = "2025-05-08T16:06:20.394Z" }, { url = "https://files.pythonhosted.org/packages/56/30/a6f08f84ee5b7b28b4c597aca4cbe545535c39fe911845a96414700b64ba/scipy-1.15.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c05045d8b9bfd807ee1b9f38761993297b10b245f012b11b13b91ba8945f7e45", size = 35210199, upload-time = "2025-05-08T16:06:26.159Z" }, { url = "https://files.pythonhosted.org/packages/0b/1f/03f52c282437a168ee2c7c14a1a0d0781a9a4a8962d84ac05c06b4c5b555/scipy-1.15.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:271e3713e645149ea5ea3e97b57fdab61ce61333f97cfae392c28ba786f9bb49", size = 37309455, upload-time = "2025-05-08T16:06:32.778Z" }, { url = "https://files.pythonhosted.org/packages/89/b1/fbb53137f42c4bf630b1ffdfc2151a62d1d1b903b249f030d2b1c0280af8/scipy-1.15.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6cfd56fc1a8e53f6e89ba3a7a7251f7396412d655bca2aa5611c8ec9a6784a1e", size = 36885140, upload-time = "2025-05-08T16:06:39.249Z" }, { url = "https://files.pythonhosted.org/packages/2e/2e/025e39e339f5090df1ff266d021892694dbb7e63568edcfe43f892fa381d/scipy-1.15.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0ff17c0bb1cb32952c09217d8d1eed9b53d1463e5f1dd6052c7857f83127d539", size = 39710549, upload-time = "2025-05-08T16:06:45.729Z" }, { url = "https://files.pythonhosted.org/packages/e6/eb/3bf6ea8ab7f1503dca3a10df2e4b9c3f6b3316df07f6c0ded94b281c7101/scipy-1.15.3-cp312-cp312-win_amd64.whl", hash = "sha256:52092bc0472cfd17df49ff17e70624345efece4e1a12b23783a1ac59a1b728ed", size = 40966184, upload-time = "2025-05-08T16:06:52.623Z" }, { url = "https://files.pythonhosted.org/packages/73/18/ec27848c9baae6e0d6573eda6e01a602e5649ee72c27c3a8aad673ebecfd/scipy-1.15.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:2c620736bcc334782e24d173c0fdbb7590a0a436d2fdf39310a8902505008759", size = 38728256, upload-time = "2025-05-08T16:06:58.696Z" }, { url = "https://files.pythonhosted.org/packages/74/cd/1aef2184948728b4b6e21267d53b3339762c285a46a274ebb7863c9e4742/scipy-1.15.3-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:7e11270a000969409d37ed399585ee530b9ef6aa99d50c019de4cb01e8e54e62", size = 30109540, upload-time = "2025-05-08T16:07:04.209Z" }, { url = "https://files.pythonhosted.org/packages/5b/d8/59e452c0a255ec352bd0a833537a3bc1bfb679944c4938ab375b0a6b3a3e/scipy-1.15.3-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:8c9ed3ba2c8a2ce098163a9bdb26f891746d02136995df25227a20e71c396ebb", size = 22383115, upload-time = "2025-05-08T16:07:08.998Z" }, { url = "https://files.pythonhosted.org/packages/08/f5/456f56bbbfccf696263b47095291040655e3cbaf05d063bdc7c7517f32ac/scipy-1.15.3-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:0bdd905264c0c9cfa74a4772cdb2070171790381a5c4d312c973382fc6eaf730", size = 25163884, upload-time = "2025-05-08T16:07:14.091Z" }, { url = "https://files.pythonhosted.org/packages/a2/66/a9618b6a435a0f0c0b8a6d0a2efb32d4ec5a85f023c2b79d39512040355b/scipy-1.15.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:79167bba085c31f38603e11a267d862957cbb3ce018d8b38f79ac043bc92d825", size = 35174018, upload-time = "2025-05-08T16:07:19.427Z" }, { url = "https://files.pythonhosted.org/packages/b5/09/c5b6734a50ad4882432b6bb7c02baf757f5b2f256041da5df242e2d7e6b6/scipy-1.15.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c9deabd6d547aee2c9a81dee6cc96c6d7e9a9b1953f74850c179f91fdc729cb7", size = 37269716, upload-time = "2025-05-08T16:07:25.712Z" }, { url = "https://files.pythonhosted.org/packages/77/0a/eac00ff741f23bcabd352731ed9b8995a0a60ef57f5fd788d611d43d69a1/scipy-1.15.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:dde4fc32993071ac0c7dd2d82569e544f0bdaff66269cb475e0f369adad13f11", size = 36872342, upload-time = "2025-05-08T16:07:31.468Z" }, { url = "https://files.pythonhosted.org/packages/fe/54/4379be86dd74b6ad81551689107360d9a3e18f24d20767a2d5b9253a3f0a/scipy-1.15.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f77f853d584e72e874d87357ad70f44b437331507d1c311457bed8ed2b956126", size = 39670869, upload-time = "2025-05-08T16:07:38.002Z" }, { url = "https://files.pythonhosted.org/packages/87/2e/892ad2862ba54f084ffe8cc4a22667eaf9c2bcec6d2bff1d15713c6c0703/scipy-1.15.3-cp313-cp313-win_amd64.whl", hash = "sha256:b90ab29d0c37ec9bf55424c064312930ca5f4bde15ee8619ee44e69319aab163", size = 40988851, upload-time = "2025-05-08T16:08:33.671Z" }, { url = "https://files.pythonhosted.org/packages/1b/e9/7a879c137f7e55b30d75d90ce3eb468197646bc7b443ac036ae3fe109055/scipy-1.15.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:3ac07623267feb3ae308487c260ac684b32ea35fd81e12845039952f558047b8", size = 38863011, upload-time = "2025-05-08T16:07:44.039Z" }, { url = "https://files.pythonhosted.org/packages/51/d1/226a806bbd69f62ce5ef5f3ffadc35286e9fbc802f606a07eb83bf2359de/scipy-1.15.3-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:6487aa99c2a3d509a5227d9a5e889ff05830a06b2ce08ec30df6d79db5fcd5c5", size = 30266407, upload-time = "2025-05-08T16:07:49.891Z" }, { url = "https://files.pythonhosted.org/packages/e5/9b/f32d1d6093ab9eeabbd839b0f7619c62e46cc4b7b6dbf05b6e615bbd4400/scipy-1.15.3-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:50f9e62461c95d933d5c5ef4a1f2ebf9a2b4e83b0db374cb3f1de104d935922e", size = 22540030, upload-time = "2025-05-08T16:07:54.121Z" }, { url = "https://files.pythonhosted.org/packages/e7/29/c278f699b095c1a884f29fda126340fcc201461ee8bfea5c8bdb1c7c958b/scipy-1.15.3-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:14ed70039d182f411ffc74789a16df3835e05dc469b898233a245cdfd7f162cb", size = 25218709, upload-time = "2025-05-08T16:07:58.506Z" }, { url = "https://files.pythonhosted.org/packages/24/18/9e5374b617aba742a990581373cd6b68a2945d65cc588482749ef2e64467/scipy-1.15.3-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a769105537aa07a69468a0eefcd121be52006db61cdd8cac8a0e68980bbb723", size = 34809045, upload-time = "2025-05-08T16:08:03.929Z" }, { url = "https://files.pythonhosted.org/packages/e1/fe/9c4361e7ba2927074360856db6135ef4904d505e9b3afbbcb073c4008328/scipy-1.15.3-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9db984639887e3dffb3928d118145ffe40eff2fa40cb241a306ec57c219ebbbb", size = 36703062, upload-time = "2025-05-08T16:08:09.558Z" }, { url = "https://files.pythonhosted.org/packages/b7/8e/038ccfe29d272b30086b25a4960f757f97122cb2ec42e62b460d02fe98e9/scipy-1.15.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:40e54d5c7e7ebf1aa596c374c49fa3135f04648a0caabcb66c52884b943f02b4", size = 36393132, upload-time = "2025-05-08T16:08:15.34Z" }, { url = "https://files.pythonhosted.org/packages/10/7e/5c12285452970be5bdbe8352c619250b97ebf7917d7a9a9e96b8a8140f17/scipy-1.15.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:5e721fed53187e71d0ccf382b6bf977644c533e506c4d33c3fb24de89f5c3ed5", size = 38979503, upload-time = "2025-05-08T16:08:21.513Z" }, { url = "https://files.pythonhosted.org/packages/81/06/0a5e5349474e1cbc5757975b21bd4fad0e72ebf138c5592f191646154e06/scipy-1.15.3-cp313-cp313t-win_amd64.whl", hash = "sha256:76ad1fb5f8752eabf0fa02e4cc0336b4e8f021e2d5f061ed37d6d264db35e3ca", size = 40308097, upload-time = "2025-05-08T16:08:27.627Z" }, ] [[package]] name = "scipy" version = "1.17.0" source = { registry = "https://pypi.org/simple" } resolution-markers = [ "python_full_version >= '3.11'", ] dependencies = [ { name = "numpy" }, ] sdist = { url = "https://files.pythonhosted.org/packages/56/3e/9cca699f3486ce6bc12ff46dc2031f1ec8eb9ccc9a320fdaf925f1417426/scipy-1.17.0.tar.gz", hash = "sha256:2591060c8e648d8b96439e111ac41fd8342fdeff1876be2e19dea3fe8930454e", size = 30396830, upload-time = "2026-01-10T21:34:23.009Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/1e/4b/c89c131aa87cad2b77a54eb0fb94d633a842420fa7e919dc2f922037c3d8/scipy-1.17.0-cp311-cp311-macosx_10_14_x86_64.whl", hash = "sha256:2abd71643797bd8a106dff97894ff7869eeeb0af0f7a5ce02e4227c6a2e9d6fd", size = 31381316, upload-time = "2026-01-10T21:24:33.42Z" }, { url = "https://files.pythonhosted.org/packages/5e/5f/a6b38f79a07d74989224d5f11b55267714707582908a5f1ae854cf9a9b84/scipy-1.17.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:ef28d815f4d2686503e5f4f00edc387ae58dfd7a2f42e348bb53359538f01558", size = 27966760, upload-time = "2026-01-10T21:24:38.911Z" }, { url = "https://files.pythonhosted.org/packages/c1/20/095ad24e031ee8ed3c5975954d816b8e7e2abd731e04f8be573de8740885/scipy-1.17.0-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:272a9f16d6bb4667e8b50d25d71eddcc2158a214df1b566319298de0939d2ab7", size = 20138701, upload-time = "2026-01-10T21:24:43.249Z" }, { url = "https://files.pythonhosted.org/packages/89/11/4aad2b3858d0337756f3323f8960755704e530b27eb2a94386c970c32cbe/scipy-1.17.0-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:7204fddcbec2fe6598f1c5fdf027e9f259106d05202a959a9f1aecf036adc9f6", size = 22480574, upload-time = "2026-01-10T21:24:47.266Z" }, { url = "https://files.pythonhosted.org/packages/85/bd/f5af70c28c6da2227e510875cadf64879855193a687fb19951f0f44cfd6b/scipy-1.17.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fc02c37a5639ee67d8fb646ffded6d793c06c5622d36b35cfa8fe5ececb8f042", size = 32862414, upload-time = "2026-01-10T21:24:52.566Z" }, { url = "https://files.pythonhosted.org/packages/ef/df/df1457c4df3826e908879fe3d76bc5b6e60aae45f4ee42539512438cfd5d/scipy-1.17.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dac97a27520d66c12a34fd90a4fe65f43766c18c0d6e1c0a80f114d2260080e4", size = 35112380, upload-time = "2026-01-10T21:24:58.433Z" }, { url = "https://files.pythonhosted.org/packages/5f/bb/88e2c16bd1dd4de19d80d7c5e238387182993c2fb13b4b8111e3927ad422/scipy-1.17.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:ebb7446a39b3ae0fe8f416a9a3fdc6fba3f11c634f680f16a239c5187bc487c0", size = 34922676, upload-time = "2026-01-10T21:25:04.287Z" }, { url = "https://files.pythonhosted.org/packages/02/ba/5120242cc735f71fc002cff0303d536af4405eb265f7c60742851e7ccfe9/scipy-1.17.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:474da16199f6af66601a01546144922ce402cb17362e07d82f5a6cf8f963e449", size = 37507599, upload-time = "2026-01-10T21:25:09.851Z" }, { url = "https://files.pythonhosted.org/packages/52/c8/08629657ac6c0da198487ce8cd3de78e02cfde42b7f34117d56a3fe249dc/scipy-1.17.0-cp311-cp311-win_amd64.whl", hash = "sha256:255c0da161bd7b32a6c898e7891509e8a9289f0b1c6c7d96142ee0d2b114c2ea", size = 36380284, upload-time = "2026-01-10T21:25:15.632Z" }, { url = "https://files.pythonhosted.org/packages/6c/4a/465f96d42c6f33ad324a40049dfd63269891db9324aa66c4a1c108c6f994/scipy-1.17.0-cp311-cp311-win_arm64.whl", hash = "sha256:85b0ac3ad17fa3be50abd7e69d583d98792d7edc08367e01445a1e2076005379", size = 24370427, upload-time = "2026-01-10T21:25:20.514Z" }, { url = "https://files.pythonhosted.org/packages/0b/11/7241a63e73ba5a516f1930ac8d5b44cbbfabd35ac73a2d08ca206df007c4/scipy-1.17.0-cp312-cp312-macosx_10_14_x86_64.whl", hash = "sha256:0d5018a57c24cb1dd828bcf51d7b10e65986d549f52ef5adb6b4d1ded3e32a57", size = 31364580, upload-time = "2026-01-10T21:25:25.717Z" }, { url = "https://files.pythonhosted.org/packages/ed/1d/5057f812d4f6adc91a20a2d6f2ebcdb517fdbc87ae3acc5633c9b97c8ba5/scipy-1.17.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:88c22af9e5d5a4f9e027e26772cc7b5922fab8bcc839edb3ae33de404feebd9e", size = 27969012, upload-time = "2026-01-10T21:25:30.921Z" }, { url = "https://files.pythonhosted.org/packages/e3/21/f6ec556c1e3b6ec4e088da667d9987bb77cc3ab3026511f427dc8451187d/scipy-1.17.0-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:f3cd947f20fe17013d401b64e857c6b2da83cae567adbb75b9dcba865abc66d8", size = 20140691, upload-time = "2026-01-10T21:25:34.802Z" }, { url = "https://files.pythonhosted.org/packages/7a/fe/5e5ad04784964ba964a96f16c8d4676aa1b51357199014dce58ab7ec5670/scipy-1.17.0-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:e8c0b331c2c1f531eb51f1b4fc9ba709521a712cce58f1aa627bc007421a5306", size = 22463015, upload-time = "2026-01-10T21:25:39.277Z" }, { url = "https://files.pythonhosted.org/packages/4a/69/7c347e857224fcaf32a34a05183b9d8a7aca25f8f2d10b8a698b8388561a/scipy-1.17.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5194c445d0a1c7a6c1a4a4681b6b7c71baad98ff66d96b949097e7513c9d6742", size = 32724197, upload-time = "2026-01-10T21:25:44.084Z" }, { url = "https://files.pythonhosted.org/packages/d1/fe/66d73b76d378ba8cc2fe605920c0c75092e3a65ae746e1e767d9d020a75a/scipy-1.17.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9eeb9b5f5997f75507814ed9d298ab23f62cf79f5a3ef90031b1ee2506abdb5b", size = 35009148, upload-time = "2026-01-10T21:25:50.591Z" }, { url = "https://files.pythonhosted.org/packages/af/07/07dec27d9dc41c18d8c43c69e9e413431d20c53a0339c388bcf72f353c4b/scipy-1.17.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:40052543f7bbe921df4408f46003d6f01c6af109b9e2c8a66dd1cf6cf57f7d5d", size = 34798766, upload-time = "2026-01-10T21:25:59.41Z" }, { url = "https://files.pythonhosted.org/packages/81/61/0470810c8a093cdacd4ba7504b8a218fd49ca070d79eca23a615f5d9a0b0/scipy-1.17.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0cf46c8013fec9d3694dc572f0b54100c28405d55d3e2cb15e2895b25057996e", size = 37405953, upload-time = "2026-01-10T21:26:07.75Z" }, { url = "https://files.pythonhosted.org/packages/92/ce/672ed546f96d5d41ae78c4b9b02006cedd0b3d6f2bf5bb76ea455c320c28/scipy-1.17.0-cp312-cp312-win_amd64.whl", hash = "sha256:0937a0b0d8d593a198cededd4c439a0ea216a3f36653901ea1f3e4be949056f8", size = 36328121, upload-time = "2026-01-10T21:26:16.509Z" }, { url = "https://files.pythonhosted.org/packages/9d/21/38165845392cae67b61843a52c6455d47d0cc2a40dd495c89f4362944654/scipy-1.17.0-cp312-cp312-win_arm64.whl", hash = "sha256:f603d8a5518c7426414d1d8f82e253e454471de682ce5e39c29adb0df1efb86b", size = 24314368, upload-time = "2026-01-10T21:26:23.087Z" }, { url = "https://files.pythonhosted.org/packages/0c/51/3468fdfd49387ddefee1636f5cf6d03ce603b75205bf439bbf0e62069bfd/scipy-1.17.0-cp313-cp313-macosx_10_14_x86_64.whl", hash = "sha256:65ec32f3d32dfc48c72df4291345dae4f048749bc8d5203ee0a3f347f96c5ce6", size = 31344101, upload-time = "2026-01-10T21:26:30.25Z" }, { url = "https://files.pythonhosted.org/packages/b2/9a/9406aec58268d437636069419e6977af953d1e246df941d42d3720b7277b/scipy-1.17.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:1f9586a58039d7229ce77b52f8472c972448cded5736eaf102d5658bbac4c269", size = 27950385, upload-time = "2026-01-10T21:26:36.801Z" }, { url = "https://files.pythonhosted.org/packages/4f/98/e7342709e17afdfd1b26b56ae499ef4939b45a23a00e471dfb5375eea205/scipy-1.17.0-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:9fad7d3578c877d606b1150135c2639e9de9cecd3705caa37b66862977cc3e72", size = 20122115, upload-time = "2026-01-10T21:26:42.107Z" }, { url = "https://files.pythonhosted.org/packages/fd/0e/9eeeb5357a64fd157cbe0302c213517c541cc16b8486d82de251f3c68ede/scipy-1.17.0-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:423ca1f6584fc03936972b5f7c06961670dbba9f234e71676a7c7ccf938a0d61", size = 22442402, upload-time = "2026-01-10T21:26:48.029Z" }, { url = "https://files.pythonhosted.org/packages/c9/10/be13397a0e434f98e0c79552b2b584ae5bb1c8b2be95db421533bbca5369/scipy-1.17.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fe508b5690e9eaaa9467fc047f833af58f1152ae51a0d0aed67aa5801f4dd7d6", size = 32696338, upload-time = "2026-01-10T21:26:55.521Z" }, { url = "https://files.pythonhosted.org/packages/63/1e/12fbf2a3bb240161651c94bb5cdd0eae5d4e8cc6eaeceb74ab07b12a753d/scipy-1.17.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6680f2dfd4f6182e7d6db161344537da644d1cf85cf293f015c60a17ecf08752", size = 34977201, upload-time = "2026-01-10T21:27:03.501Z" }, { url = "https://files.pythonhosted.org/packages/19/5b/1a63923e23ccd20bd32156d7dd708af5bbde410daa993aa2500c847ab2d2/scipy-1.17.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:eec3842ec9ac9de5917899b277428886042a93db0b227ebbe3a333b64ec7643d", size = 34777384, upload-time = "2026-01-10T21:27:11.423Z" }, { url = "https://files.pythonhosted.org/packages/39/22/b5da95d74edcf81e540e467202a988c50fef41bd2011f46e05f72ba07df6/scipy-1.17.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d7425fcafbc09a03731e1bc05581f5fad988e48c6a861f441b7ab729a49a55ea", size = 37379586, upload-time = "2026-01-10T21:27:20.171Z" }, { url = "https://files.pythonhosted.org/packages/b9/b6/8ac583d6da79e7b9e520579f03007cb006f063642afd6b2eeb16b890bf93/scipy-1.17.0-cp313-cp313-win_amd64.whl", hash = "sha256:87b411e42b425b84777718cc41516b8a7e0795abfa8e8e1d573bf0ef014f0812", size = 36287211, upload-time = "2026-01-10T21:28:43.122Z" }, { url = "https://files.pythonhosted.org/packages/55/fb/7db19e0b3e52f882b420417644ec81dd57eeef1bd1705b6f689d8ff93541/scipy-1.17.0-cp313-cp313-win_arm64.whl", hash = "sha256:357ca001c6e37601066092e7c89cca2f1ce74e2a520ca78d063a6d2201101df2", size = 24312646, upload-time = "2026-01-10T21:28:49.893Z" }, { url = "https://files.pythonhosted.org/packages/20/b6/7feaa252c21cc7aff335c6c55e1b90ab3e3306da3f048109b8b639b94648/scipy-1.17.0-cp313-cp313t-macosx_10_14_x86_64.whl", hash = "sha256:ec0827aa4d36cb79ff1b81de898e948a51ac0b9b1c43e4a372c0508c38c0f9a3", size = 31693194, upload-time = "2026-01-10T21:27:27.454Z" }, { url = "https://files.pythonhosted.org/packages/76/bb/bbb392005abce039fb7e672cb78ac7d158700e826b0515cab6b5b60c26fb/scipy-1.17.0-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:819fc26862b4b3c73a60d486dbb919202f3d6d98c87cf20c223511429f2d1a97", size = 28365415, upload-time = "2026-01-10T21:27:34.26Z" }, { url = "https://files.pythonhosted.org/packages/37/da/9d33196ecc99fba16a409c691ed464a3a283ac454a34a13a3a57c0d66f3a/scipy-1.17.0-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:363ad4ae2853d88ebcde3ae6ec46ccca903ea9835ee8ba543f12f575e7b07e4e", size = 20537232, upload-time = "2026-01-10T21:27:40.306Z" }, { url = "https://files.pythonhosted.org/packages/56/9d/f4b184f6ddb28e9a5caea36a6f98e8ecd2a524f9127354087ce780885d83/scipy-1.17.0-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:979c3a0ff8e5ba254d45d59ebd38cde48fce4f10b5125c680c7a4bfe177aab07", size = 22791051, upload-time = "2026-01-10T21:27:46.539Z" }, { url = "https://files.pythonhosted.org/packages/9b/9d/025cccdd738a72140efc582b1641d0dd4caf2e86c3fb127568dc80444e6e/scipy-1.17.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:130d12926ae34399d157de777472bf82e9061c60cc081372b3118edacafe1d00", size = 32815098, upload-time = "2026-01-10T21:27:54.389Z" }, { url = "https://files.pythonhosted.org/packages/48/5f/09b879619f8bca15ce392bfc1894bd9c54377e01d1b3f2f3b595a1b4d945/scipy-1.17.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6e886000eb4919eae3a44f035e63f0fd8b651234117e8f6f29bad1cd26e7bc45", size = 35031342, upload-time = "2026-01-10T21:28:03.012Z" }, { url = "https://files.pythonhosted.org/packages/f2/9a/f0f0a9f0aa079d2f106555b984ff0fbb11a837df280f04f71f056ea9c6e4/scipy-1.17.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:13c4096ac6bc31d706018f06a49abe0485f96499deb82066b94d19b02f664209", size = 34893199, upload-time = "2026-01-10T21:28:10.832Z" }, { url = "https://files.pythonhosted.org/packages/90/b8/4f0f5cf0c5ea4d7548424e6533e6b17d164f34a6e2fb2e43ffebb6697b06/scipy-1.17.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:cacbaddd91fcffde703934897c5cd2c7cb0371fac195d383f4e1f1c5d3f3bd04", size = 37438061, upload-time = "2026-01-10T21:28:19.684Z" }, { url = "https://files.pythonhosted.org/packages/f9/cc/2bd59140ed3b2fa2882fb15da0a9cb1b5a6443d67cfd0d98d4cec83a57ec/scipy-1.17.0-cp313-cp313t-win_amd64.whl", hash = "sha256:edce1a1cf66298cccdc48a1bdf8fb10a3bf58e8b58d6c3883dd1530e103f87c0", size = 36328593, upload-time = "2026-01-10T21:28:28.007Z" }, { url = "https://files.pythonhosted.org/packages/13/1b/c87cc44a0d2c7aaf0f003aef2904c3d097b422a96c7e7c07f5efd9073c1b/scipy-1.17.0-cp313-cp313t-win_arm64.whl", hash = "sha256:30509da9dbec1c2ed8f168b8d8aa853bc6723fede1dbc23c7d43a56f5ab72a67", size = 24625083, upload-time = "2026-01-10T21:28:35.188Z" }, { url = "https://files.pythonhosted.org/packages/1a/2d/51006cd369b8e7879e1c630999a19d1fbf6f8b5ed3e33374f29dc87e53b3/scipy-1.17.0-cp314-cp314-macosx_10_14_x86_64.whl", hash = "sha256:c17514d11b78be8f7e6331b983a65a7f5ca1fd037b95e27b280921fe5606286a", size = 31346803, upload-time = "2026-01-10T21:28:57.24Z" }, { url = "https://files.pythonhosted.org/packages/d6/2e/2349458c3ce445f53a6c93d4386b1c4c5c0c540917304c01222ff95ff317/scipy-1.17.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:4e00562e519c09da34c31685f6acc3aa384d4d50604db0f245c14e1b4488bfa2", size = 27967182, upload-time = "2026-01-10T21:29:04.107Z" }, { url = "https://files.pythonhosted.org/packages/5e/7c/df525fbfa77b878d1cfe625249529514dc02f4fd5f45f0f6295676a76528/scipy-1.17.0-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:f7df7941d71314e60a481e02d5ebcb3f0185b8d799c70d03d8258f6c80f3d467", size = 20139125, upload-time = "2026-01-10T21:29:10.179Z" }, { url = "https://files.pythonhosted.org/packages/33/11/fcf9d43a7ed1234d31765ec643b0515a85a30b58eddccc5d5a4d12b5f194/scipy-1.17.0-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:aabf057c632798832f071a8dde013c2e26284043934f53b00489f1773b33527e", size = 22443554, upload-time = "2026-01-10T21:29:15.888Z" }, { url = "https://files.pythonhosted.org/packages/80/5c/ea5d239cda2dd3d31399424967a24d556cf409fbea7b5b21412b0fd0a44f/scipy-1.17.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a38c3337e00be6fd8a95b4ed66b5d988bac4ec888fd922c2ea9fe5fb1603dd67", size = 32757834, upload-time = "2026-01-10T21:29:23.406Z" }, { url = "https://files.pythonhosted.org/packages/b8/7e/8c917cc573310e5dc91cbeead76f1b600d3fb17cf0969db02c9cf92e3cfa/scipy-1.17.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00fb5f8ec8398ad90215008d8b6009c9db9fa924fd4c7d6be307c6f945f9cd73", size = 34995775, upload-time = "2026-01-10T21:29:31.915Z" }, { url = "https://files.pythonhosted.org/packages/c5/43/176c0c3c07b3f7df324e7cdd933d3e2c4898ca202b090bd5ba122f9fe270/scipy-1.17.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f2a4942b0f5f7c23c7cd641a0ca1955e2ae83dedcff537e3a0259096635e186b", size = 34841240, upload-time = "2026-01-10T21:29:39.995Z" }, { url = "https://files.pythonhosted.org/packages/44/8c/d1f5f4b491160592e7f084d997de53a8e896a3ac01cd07e59f43ca222744/scipy-1.17.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:dbf133ced83889583156566d2bdf7a07ff89228fe0c0cb727f777de92092ec6b", size = 37394463, upload-time = "2026-01-10T21:29:48.723Z" }, { url = "https://files.pythonhosted.org/packages/9f/ec/42a6657f8d2d087e750e9a5dde0b481fd135657f09eaf1cf5688bb23c338/scipy-1.17.0-cp314-cp314-win_amd64.whl", hash = "sha256:3625c631a7acd7cfd929e4e31d2582cf00f42fcf06011f59281271746d77e061", size = 37053015, upload-time = "2026-01-10T21:30:51.418Z" }, { url = "https://files.pythonhosted.org/packages/27/58/6b89a6afd132787d89a362d443a7bddd511b8f41336a1ae47f9e4f000dc4/scipy-1.17.0-cp314-cp314-win_arm64.whl", hash = "sha256:9244608d27eafe02b20558523ba57f15c689357c85bdcfe920b1828750aa26eb", size = 24951312, upload-time = "2026-01-10T21:30:56.771Z" }, { url = "https://files.pythonhosted.org/packages/e9/01/f58916b9d9ae0112b86d7c3b10b9e685625ce6e8248df139d0fcb17f7397/scipy-1.17.0-cp314-cp314t-macosx_10_14_x86_64.whl", hash = "sha256:2b531f57e09c946f56ad0b4a3b2abee778789097871fc541e267d2eca081cff1", size = 31706502, upload-time = "2026-01-10T21:29:56.326Z" }, { url = "https://files.pythonhosted.org/packages/59/8e/2912a87f94a7d1f8b38aabc0faf74b82d3b6c9e22be991c49979f0eceed8/scipy-1.17.0-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:13e861634a2c480bd237deb69333ac79ea1941b94568d4b0efa5db5e263d4fd1", size = 28380854, upload-time = "2026-01-10T21:30:01.554Z" }, { url = "https://files.pythonhosted.org/packages/bd/1c/874137a52dddab7d5d595c1887089a2125d27d0601fce8c0026a24a92a0b/scipy-1.17.0-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:eb2651271135154aa24f6481cbae5cc8af1f0dd46e6533fb7b56aa9727b6a232", size = 20552752, upload-time = "2026-01-10T21:30:05.93Z" }, { url = "https://files.pythonhosted.org/packages/3f/f0/7518d171cb735f6400f4576cf70f756d5b419a07fe1867da34e2c2c9c11b/scipy-1.17.0-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:c5e8647f60679790c2f5c76be17e2e9247dc6b98ad0d3b065861e082c56e078d", size = 22803972, upload-time = "2026-01-10T21:30:10.651Z" }, { url = "https://files.pythonhosted.org/packages/7c/74/3498563a2c619e8a3ebb4d75457486c249b19b5b04a30600dfd9af06bea5/scipy-1.17.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5fb10d17e649e1446410895639f3385fd2bf4c3c7dfc9bea937bddcbc3d7b9ba", size = 32829770, upload-time = "2026-01-10T21:30:16.359Z" }, { url = "https://files.pythonhosted.org/packages/48/d1/7b50cedd8c6c9d6f706b4b36fa8544d829c712a75e370f763b318e9638c1/scipy-1.17.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8547e7c57f932e7354a2319fab613981cde910631979f74c9b542bb167a8b9db", size = 35051093, upload-time = "2026-01-10T21:30:22.987Z" }, { url = "https://files.pythonhosted.org/packages/e2/82/a2d684dfddb87ba1b3ea325df7c3293496ee9accb3a19abe9429bce94755/scipy-1.17.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:33af70d040e8af9d5e7a38b5ed3b772adddd281e3062ff23fec49e49681c38cf", size = 34909905, upload-time = "2026-01-10T21:30:28.704Z" }, { url = "https://files.pythonhosted.org/packages/ef/5e/e565bd73991d42023eb82bb99e51c5b3d9e2c588ca9d4b3e2cc1d3ca62a6/scipy-1.17.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f9eb55bb97d00f8b7ab95cb64f873eb0bf54d9446264d9f3609130381233483f", size = 37457743, upload-time = "2026-01-10T21:30:34.819Z" }, { url = "https://files.pythonhosted.org/packages/58/a8/a66a75c3d8f1fb2b83f66007d6455a06a6f6cf5618c3dc35bc9b69dd096e/scipy-1.17.0-cp314-cp314t-win_amd64.whl", hash = "sha256:1ff269abf702f6c7e67a4b7aad981d42871a11b9dd83c58d2d2ea624efbd1088", size = 37098574, upload-time = "2026-01-10T21:30:40.782Z" }, { url = "https://files.pythonhosted.org/packages/56/a5/df8f46ef7da168f1bc52cd86e09a9de5c6f19cc1da04454d51b7d4f43408/scipy-1.17.0-cp314-cp314t-win_arm64.whl", hash = "sha256:031121914e295d9791319a1875444d55079885bbae5bdc9c5e0f2ee5f09d34ff", size = 25246266, upload-time = "2026-01-10T21:30:45.923Z" }, ] [[package]] name = "tomli" version = "2.4.0" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/82/30/31573e9457673ab10aa432461bee537ce6cef177667deca369efb79df071/tomli-2.4.0.tar.gz", hash = "sha256:aa89c3f6c277dd275d8e243ad24f3b5e701491a860d5121f2cdd399fbb31fc9c", size = 17477, upload-time = "2026-01-11T11:22:38.165Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/3c/d9/3dc2289e1f3b32eb19b9785b6a006b28ee99acb37d1d47f78d4c10e28bf8/tomli-2.4.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b5ef256a3fd497d4973c11bf142e9ed78b150d36f5773f1ca6088c230ffc5867", size = 153663, upload-time = "2026-01-11T11:21:45.27Z" }, { url = "https://files.pythonhosted.org/packages/51/32/ef9f6845e6b9ca392cd3f64f9ec185cc6f09f0a2df3db08cbe8809d1d435/tomli-2.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5572e41282d5268eb09a697c89a7bee84fae66511f87533a6f88bd2f7b652da9", size = 148469, upload-time = "2026-01-11T11:21:46.873Z" }, { url = "https://files.pythonhosted.org/packages/d6/c2/506e44cce89a8b1b1e047d64bd495c22c9f71f21e05f380f1a950dd9c217/tomli-2.4.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:551e321c6ba03b55676970b47cb1b73f14a0a4dce6a3e1a9458fd6d921d72e95", size = 236039, upload-time = "2026-01-11T11:21:48.503Z" }, { url = "https://files.pythonhosted.org/packages/b3/40/e1b65986dbc861b7e986e8ec394598187fa8aee85b1650b01dd925ca0be8/tomli-2.4.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5e3f639a7a8f10069d0e15408c0b96a2a828cfdec6fca05296ebcdcc28ca7c76", size = 243007, upload-time = "2026-01-11T11:21:49.456Z" }, { url = "https://files.pythonhosted.org/packages/9c/6f/6e39ce66b58a5b7ae572a0f4352ff40c71e8573633deda43f6a379d56b3e/tomli-2.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1b168f2731796b045128c45982d3a4874057626da0e2ef1fdd722848b741361d", size = 240875, upload-time = "2026-01-11T11:21:50.755Z" }, { url = "https://files.pythonhosted.org/packages/aa/ad/cb089cb190487caa80204d503c7fd0f4d443f90b95cf4ef5cf5aa0f439b0/tomli-2.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:133e93646ec4300d651839d382d63edff11d8978be23da4cc106f5a18b7d0576", size = 246271, upload-time = "2026-01-11T11:21:51.81Z" }, { url = "https://files.pythonhosted.org/packages/0b/63/69125220e47fd7a3a27fd0de0c6398c89432fec41bc739823bcc66506af6/tomli-2.4.0-cp311-cp311-win32.whl", hash = "sha256:b6c78bdf37764092d369722d9946cb65b8767bfa4110f902a1b2542d8d173c8a", size = 96770, upload-time = "2026-01-11T11:21:52.647Z" }, { url = "https://files.pythonhosted.org/packages/1e/0d/a22bb6c83f83386b0008425a6cd1fa1c14b5f3dd4bad05e98cf3dbbf4a64/tomli-2.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:d3d1654e11d724760cdb37a3d7691f0be9db5fbdaef59c9f532aabf87006dbaa", size = 107626, upload-time = "2026-01-11T11:21:53.459Z" }, { url = "https://files.pythonhosted.org/packages/2f/6d/77be674a3485e75cacbf2ddba2b146911477bd887dda9d8c9dfb2f15e871/tomli-2.4.0-cp311-cp311-win_arm64.whl", hash = "sha256:cae9c19ed12d4e8f3ebf46d1a75090e4c0dc16271c5bce1c833ac168f08fb614", size = 94842, upload-time = "2026-01-11T11:21:54.831Z" }, { url = "https://files.pythonhosted.org/packages/3c/43/7389a1869f2f26dba52404e1ef13b4784b6b37dac93bac53457e3ff24ca3/tomli-2.4.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:920b1de295e72887bafa3ad9f7a792f811847d57ea6b1215154030cf131f16b1", size = 154894, upload-time = "2026-01-11T11:21:56.07Z" }, { url = "https://files.pythonhosted.org/packages/e9/05/2f9bf110b5294132b2edf13fe6ca6ae456204f3d749f623307cbb7a946f2/tomli-2.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7d6d9a4aee98fac3eab4952ad1d73aee87359452d1c086b5ceb43ed02ddb16b8", size = 149053, upload-time = "2026-01-11T11:21:57.467Z" }, { url = "https://files.pythonhosted.org/packages/e8/41/1eda3ca1abc6f6154a8db4d714a4d35c4ad90adc0bcf700657291593fbf3/tomli-2.4.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:36b9d05b51e65b254ea6c2585b59d2c4cb91c8a3d91d0ed0f17591a29aaea54a", size = 243481, upload-time = "2026-01-11T11:21:58.661Z" }, { url = "https://files.pythonhosted.org/packages/d2/6d/02ff5ab6c8868b41e7d4b987ce2b5f6a51d3335a70aa144edd999e055a01/tomli-2.4.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1c8a885b370751837c029ef9bc014f27d80840e48bac415f3412e6593bbc18c1", size = 251720, upload-time = "2026-01-11T11:22:00.178Z" }, { url = "https://files.pythonhosted.org/packages/7b/57/0405c59a909c45d5b6f146107c6d997825aa87568b042042f7a9c0afed34/tomli-2.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8768715ffc41f0008abe25d808c20c3d990f42b6e2e58305d5da280ae7d1fa3b", size = 247014, upload-time = "2026-01-11T11:22:01.238Z" }, { url = "https://files.pythonhosted.org/packages/2c/0e/2e37568edd944b4165735687cbaf2fe3648129e440c26d02223672ee0630/tomli-2.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7b438885858efd5be02a9a133caf5812b8776ee0c969fea02c45e8e3f296ba51", size = 251820, upload-time = "2026-01-11T11:22:02.727Z" }, { url = "https://files.pythonhosted.org/packages/5a/1c/ee3b707fdac82aeeb92d1a113f803cf6d0f37bdca0849cb489553e1f417a/tomli-2.4.0-cp312-cp312-win32.whl", hash = "sha256:0408e3de5ec77cc7f81960c362543cbbd91ef883e3138e81b729fc3eea5b9729", size = 97712, upload-time = "2026-01-11T11:22:03.777Z" }, { url = "https://files.pythonhosted.org/packages/69/13/c07a9177d0b3bab7913299b9278845fc6eaaca14a02667c6be0b0a2270c8/tomli-2.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:685306e2cc7da35be4ee914fd34ab801a6acacb061b6a7abca922aaf9ad368da", size = 108296, upload-time = "2026-01-11T11:22:04.86Z" }, { url = "https://files.pythonhosted.org/packages/18/27/e267a60bbeeee343bcc279bb9e8fbed0cbe224bc7b2a3dc2975f22809a09/tomli-2.4.0-cp312-cp312-win_arm64.whl", hash = "sha256:5aa48d7c2356055feef06a43611fc401a07337d5b006be13a30f6c58f869e3c3", size = 94553, upload-time = "2026-01-11T11:22:05.854Z" }, { url = "https://files.pythonhosted.org/packages/34/91/7f65f9809f2936e1f4ce6268ae1903074563603b2a2bd969ebbda802744f/tomli-2.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:84d081fbc252d1b6a982e1870660e7330fb8f90f676f6e78b052ad4e64714bf0", size = 154915, upload-time = "2026-01-11T11:22:06.703Z" }, { url = "https://files.pythonhosted.org/packages/20/aa/64dd73a5a849c2e8f216b755599c511badde80e91e9bc2271baa7b2cdbb1/tomli-2.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:9a08144fa4cba33db5255f9b74f0b89888622109bd2776148f2597447f92a94e", size = 149038, upload-time = "2026-01-11T11:22:07.56Z" }, { url = "https://files.pythonhosted.org/packages/9e/8a/6d38870bd3d52c8d1505ce054469a73f73a0fe62c0eaf5dddf61447e32fa/tomli-2.4.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c73add4bb52a206fd0c0723432db123c0c75c280cbd67174dd9d2db228ebb1b4", size = 242245, upload-time = "2026-01-11T11:22:08.344Z" }, { url = "https://files.pythonhosted.org/packages/59/bb/8002fadefb64ab2669e5b977df3f5e444febea60e717e755b38bb7c41029/tomli-2.4.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1fb2945cbe303b1419e2706e711b7113da57b7db31ee378d08712d678a34e51e", size = 250335, upload-time = "2026-01-11T11:22:09.951Z" }, { url = "https://files.pythonhosted.org/packages/a5/3d/4cdb6f791682b2ea916af2de96121b3cb1284d7c203d97d92d6003e91c8d/tomli-2.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bbb1b10aa643d973366dc2cb1ad94f99c1726a02343d43cbc011edbfac579e7c", size = 245962, upload-time = "2026-01-11T11:22:11.27Z" }, { url = "https://files.pythonhosted.org/packages/f2/4a/5f25789f9a460bd858ba9756ff52d0830d825b458e13f754952dd15fb7bb/tomli-2.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4cbcb367d44a1f0c2be408758b43e1ffb5308abe0ea222897d6bfc8e8281ef2f", size = 250396, upload-time = "2026-01-11T11:22:12.325Z" }, { url = "https://files.pythonhosted.org/packages/aa/2f/b73a36fea58dfa08e8b3a268750e6853a6aac2a349241a905ebd86f3047a/tomli-2.4.0-cp313-cp313-win32.whl", hash = "sha256:7d49c66a7d5e56ac959cb6fc583aff0651094ec071ba9ad43df785abc2320d86", size = 97530, upload-time = "2026-01-11T11:22:13.865Z" }, { url = "https://files.pythonhosted.org/packages/3b/af/ca18c134b5d75de7e8dc551c5234eaba2e8e951f6b30139599b53de9c187/tomli-2.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:3cf226acb51d8f1c394c1b310e0e0e61fecdd7adcb78d01e294ac297dd2e7f87", size = 108227, upload-time = "2026-01-11T11:22:15.224Z" }, { url = "https://files.pythonhosted.org/packages/22/c3/b386b832f209fee8073c8138ec50f27b4460db2fdae9ffe022df89a57f9b/tomli-2.4.0-cp313-cp313-win_arm64.whl", hash = "sha256:d20b797a5c1ad80c516e41bc1fb0443ddb5006e9aaa7bda2d71978346aeb9132", size = 94748, upload-time = "2026-01-11T11:22:16.009Z" }, { url = "https://files.pythonhosted.org/packages/f3/c4/84047a97eb1004418bc10bdbcfebda209fca6338002eba2dc27cc6d13563/tomli-2.4.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:26ab906a1eb794cd4e103691daa23d95c6919cc2fa9160000ac02370cc9dd3f6", size = 154725, upload-time = "2026-01-11T11:22:17.269Z" }, { url = "https://files.pythonhosted.org/packages/a8/5d/d39038e646060b9d76274078cddf146ced86dc2b9e8bbf737ad5983609a0/tomli-2.4.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:20cedb4ee43278bc4f2fee6cb50daec836959aadaf948db5172e776dd3d993fc", size = 148901, upload-time = "2026-01-11T11:22:18.287Z" }, { url = "https://files.pythonhosted.org/packages/73/e5/383be1724cb30f4ce44983d249645684a48c435e1cd4f8b5cded8a816d3c/tomli-2.4.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:39b0b5d1b6dd03684b3fb276407ebed7090bbec989fa55838c98560c01113b66", size = 243375, upload-time = "2026-01-11T11:22:19.154Z" }, { url = "https://files.pythonhosted.org/packages/31/f0/bea80c17971c8d16d3cc109dc3585b0f2ce1036b5f4a8a183789023574f2/tomli-2.4.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a26d7ff68dfdb9f87a016ecfd1e1c2bacbe3108f4e0f8bcd2228ef9a766c787d", size = 250639, upload-time = "2026-01-11T11:22:20.168Z" }, { url = "https://files.pythonhosted.org/packages/2c/8f/2853c36abbb7608e3f945d8a74e32ed3a74ee3a1f468f1ffc7d1cb3abba6/tomli-2.4.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:20ffd184fb1df76a66e34bd1b36b4a4641bd2b82954befa32fe8163e79f1a702", size = 246897, upload-time = "2026-01-11T11:22:21.544Z" }, { url = "https://files.pythonhosted.org/packages/49/f0/6c05e3196ed5337b9fe7ea003e95fd3819a840b7a0f2bf5a408ef1dad8ed/tomli-2.4.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:75c2f8bbddf170e8effc98f5e9084a8751f8174ea6ccf4fca5398436e0320bc8", size = 254697, upload-time = "2026-01-11T11:22:23.058Z" }, { url = "https://files.pythonhosted.org/packages/f3/f5/2922ef29c9f2951883525def7429967fc4d8208494e5ab524234f06b688b/tomli-2.4.0-cp314-cp314-win32.whl", hash = "sha256:31d556d079d72db7c584c0627ff3a24c5d3fb4f730221d3444f3efb1b2514776", size = 98567, upload-time = "2026-01-11T11:22:24.033Z" }, { url = "https://files.pythonhosted.org/packages/7b/31/22b52e2e06dd2a5fdbc3ee73226d763b184ff21fc24e20316a44ccc4d96b/tomli-2.4.0-cp314-cp314-win_amd64.whl", hash = "sha256:43e685b9b2341681907759cf3a04e14d7104b3580f808cfde1dfdb60ada85475", size = 108556, upload-time = "2026-01-11T11:22:25.378Z" }, { url = "https://files.pythonhosted.org/packages/48/3d/5058dff3255a3d01b705413f64f4306a141a8fd7a251e5a495e3f192a998/tomli-2.4.0-cp314-cp314-win_arm64.whl", hash = "sha256:3d895d56bd3f82ddd6faaff993c275efc2ff38e52322ea264122d72729dca2b2", size = 96014, upload-time = "2026-01-11T11:22:26.138Z" }, { url = "https://files.pythonhosted.org/packages/b8/4e/75dab8586e268424202d3a1997ef6014919c941b50642a1682df43204c22/tomli-2.4.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:5b5807f3999fb66776dbce568cc9a828544244a8eb84b84b9bafc080c99597b9", size = 163339, upload-time = "2026-01-11T11:22:27.143Z" }, { url = "https://files.pythonhosted.org/packages/06/e3/b904d9ab1016829a776d97f163f183a48be6a4deb87304d1e0116a349519/tomli-2.4.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c084ad935abe686bd9c898e62a02a19abfc9760b5a79bc29644463eaf2840cb0", size = 159490, upload-time = "2026-01-11T11:22:28.399Z" }, { url = "https://files.pythonhosted.org/packages/e3/5a/fc3622c8b1ad823e8ea98a35e3c632ee316d48f66f80f9708ceb4f2a0322/tomli-2.4.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0f2e3955efea4d1cfbcb87bc321e00dc08d2bcb737fd1d5e398af111d86db5df", size = 269398, upload-time = "2026-01-11T11:22:29.345Z" }, { url = "https://files.pythonhosted.org/packages/fd/33/62bd6152c8bdd4c305ad9faca48f51d3acb2df1f8791b1477d46ff86e7f8/tomli-2.4.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0e0fe8a0b8312acf3a88077a0802565cb09ee34107813bba1c7cd591fa6cfc8d", size = 276515, upload-time = "2026-01-11T11:22:30.327Z" }, { url = "https://files.pythonhosted.org/packages/4b/ff/ae53619499f5235ee4211e62a8d7982ba9e439a0fb4f2f351a93d67c1dd2/tomli-2.4.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:413540dce94673591859c4c6f794dfeaa845e98bf35d72ed59636f869ef9f86f", size = 273806, upload-time = "2026-01-11T11:22:32.56Z" }, { url = "https://files.pythonhosted.org/packages/47/71/cbca7787fa68d4d0a9f7072821980b39fbb1b6faeb5f5cf02f4a5559fa28/tomli-2.4.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:0dc56fef0e2c1c470aeac5b6ca8cc7b640bb93e92d9803ddaf9ea03e198f5b0b", size = 281340, upload-time = "2026-01-11T11:22:33.505Z" }, { url = "https://files.pythonhosted.org/packages/f5/00/d595c120963ad42474cf6ee7771ad0d0e8a49d0f01e29576ee9195d9ecdf/tomli-2.4.0-cp314-cp314t-win32.whl", hash = "sha256:d878f2a6707cc9d53a1be1414bbb419e629c3d6e67f69230217bb663e76b5087", size = 108106, upload-time = "2026-01-11T11:22:34.451Z" }, { url = "https://files.pythonhosted.org/packages/de/69/9aa0c6a505c2f80e519b43764f8b4ba93b5a0bbd2d9a9de6e2b24271b9a5/tomli-2.4.0-cp314-cp314t-win_amd64.whl", hash = "sha256:2add28aacc7425117ff6364fe9e06a183bb0251b03f986df0e78e974047571fd", size = 120504, upload-time = "2026-01-11T11:22:35.764Z" }, { url = "https://files.pythonhosted.org/packages/b3/9f/f1668c281c58cfae01482f7114a4b88d345e4c140386241a1a24dcc9e7bc/tomli-2.4.0-cp314-cp314t-win_arm64.whl", hash = "sha256:2b1e3b80e1d5e52e40e9b924ec43d81570f0e7d09d11081b797bc4692765a3d4", size = 99561, upload-time = "2026-01-11T11:22:36.624Z" }, { url = "https://files.pythonhosted.org/packages/23/d1/136eb2cb77520a31e1f64cbae9d33ec6df0d78bdf4160398e86eec8a8754/tomli-2.4.0-py3-none-any.whl", hash = "sha256:1f776e7d669ebceb01dee46484485f43a4048746235e683bcdffacdf1fb4785a", size = 14477, upload-time = "2026-01-11T11:22:37.446Z" }, ] [[package]] name = "typing-extensions" version = "4.15.0" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" }, ] [[package]] name = "virtualenv" version = "21.2.4" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "distlib" }, { name = "filelock" }, { name = "platformdirs" }, { name = "python-discovery" }, { name = "typing-extensions", marker = "python_full_version < '3.11'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/0c/98/3a7e644e19cb26133488caff231be390579860bbbb3da35913c49a1d0a46/virtualenv-21.2.4.tar.gz", hash = "sha256:b294ef68192638004d72524ce7ef303e9d0cf5a44c95ce2e54a7500a6381cada", size = 5850742, upload-time = "2026-04-14T22:15:31.438Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/27/8d/edd0bd910ff803c308ee9a6b7778621af0d10252219ad9f19ef4d4982a61/virtualenv-21.2.4-py3-none-any.whl", hash = "sha256:29d21e941795206138d0f22f4e45ff7050e5da6c6472299fb7103318763861ac", size = 5831232, upload-time = "2026-04-14T22:15:29.342Z" }, ]