Repository: benfred/py-spy Branch: master Commit: 5e14e32f8d43 Files: 73 Total size: 1.8 MB Directory structure: gitextract_n9_1d35r/ ├── .cargo/ │ └── config.toml ├── .github/ │ ├── dependabot.yml │ ├── release-drafter.yml │ └── workflows/ │ ├── build.yml │ ├── release-drafter.yml │ └── update_python_test.yml ├── .gitignore ├── .pre-commit-config.yaml ├── CHANGELOG.md ├── Cargo.toml ├── LICENSE ├── README.md ├── SECURITY.md ├── build.rs ├── ci/ │ ├── Vagrantfile │ ├── publish_freebsd.sh │ ├── test_freebsd.sh │ ├── testdata/ │ │ ├── cython_test.c │ │ └── cython_test.pyx │ └── update_python_test_versions.py ├── examples/ │ └── dump_traces.rs ├── generate_bindings.py ├── pyproject.toml ├── setup.cfg ├── src/ │ ├── binary_parser.rs │ ├── chrometrace.rs │ ├── config.rs │ ├── console_viewer.rs │ ├── coredump.rs │ ├── cython.rs │ ├── dump.rs │ ├── flamegraph.rs │ ├── lib.rs │ ├── main.rs │ ├── native_stack_trace.rs │ ├── python_bindings/ │ │ ├── mod.rs │ │ ├── v2_7_15.rs │ │ ├── v3_10_0.rs │ │ ├── v3_11_0.rs │ │ ├── v3_12_0.rs │ │ ├── v3_13_0.rs │ │ ├── v3_3_7.rs │ │ ├── v3_4_8.rs │ │ ├── v3_5_5.rs │ │ ├── v3_6_6.rs │ │ ├── v3_7_0.rs │ │ ├── v3_8_0.rs │ │ └── v3_9_5.rs │ ├── python_data_access.rs │ ├── python_interpreters.rs │ ├── python_process_info.rs │ ├── python_spy.rs │ ├── python_threading.rs │ ├── sampler.rs │ ├── speedscope.rs │ ├── stack_trace.rs │ ├── timer.rs │ ├── utils.rs │ └── version.rs └── tests/ ├── integration_test.py ├── integration_test.rs └── scripts/ ├── busyloop.py ├── cyrillic.py ├── delayed_launch.sh ├── local_vars.py ├── longsleep.py ├── negative_linenumber_offsets.py ├── recursive.py ├── subprocesses.py ├── subprocesses_zombie_child.py ├── thread_names.py ├── thread_reuse.py └── unicode💩.py ================================================ FILE CONTENTS ================================================ ================================================ FILE: .cargo/config.toml ================================================ [target.armv7-unknown-linux-gnueabihf] linker = "arm-linux-gnueabihf-gcc" ================================================ FILE: .github/dependabot.yml ================================================ # Keep GitHub Actions up to date with GitHub's Dependabot... # https://docs.github.com/en/code-security/dependabot/working-with-dependabot/keeping-your-actions-up-to-date-with-dependabot # https://docs.github.com/en/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file#package-ecosystem version: 2 updates: - package-ecosystem: github-actions directory: / groups: github-actions: patterns: - "*" # Group all Actions updates into a single larger pull request schedule: interval: weekly ================================================ FILE: .github/release-drafter.yml ================================================ categories: - title: "⚠ Breaking Changes" labels: - "breaking" - title: "🚀 Features" labels: - "feature" - "enhancement" - title: "🐛 Bug Fixes" labels: - "fix" - "bugfix" - "bug" - title: "📄 Documentation" labels: - "documentation" - title: "🧰 Maintenance" label: - "chore" - "ci" - "dependencies" exclude-labels: - "skip-changelog" change-template: "- $TITLE @$AUTHOR (#$NUMBER)" change-title-escapes: '\<*_&' # You can add # and @ to disable mentions, and add ` to disable code blocks. version-resolver: major: labels: - "major" minor: labels: - "minor" patch: labels: - "patch" default: patch template: | ## Changes $CHANGES ================================================ FILE: .github/workflows/build.yml ================================================ name: Build on: workflow_dispatch: push: branches: [master] tags: - v* pull_request: branches: [master] env: CARGO_TERM_COLOR: always jobs: lint: runs-on: ubuntu-latest steps: - uses: actions/checkout@v5 - uses: actions/setup-python@v5 with: python-version: 3.11 - uses: pre-commit/action@v3.0.1 build: runs-on: ${{ matrix.os }} needs: [lint] strategy: fail-fast: false matrix: os: [ubuntu-latest, windows-latest, macos-latest] steps: - uses: actions/checkout@v5 - uses: Swatinem/rust-cache@v2 - name: Install Dependencies run: sudo apt install libunwind-dev if: runner.os == 'Linux' - uses: actions/setup-python@v5 with: python-version: 3.9 - name: Build run: cargo build --release --verbose --examples - uses: actions/setup-python@v5 with: python-version: 3.9 - name: Install optional numpy dependency run: pip install numpy>=2 - name: Test id: test continue-on-error: true run: cargo test --release - name: Test (retry#1) id: test1 run: cargo test --release if: steps.test.outcome=='failure' continue-on-error: true - name: Test (retry#2) run: cargo test --release if: steps.test1.outcome=='failure' - name: Build Wheel run: | pip install --upgrade maturin maturin build --release -o dist --all-features if: runner.os == 'Windows' - name: Build Wheel - universal2 env: DEVELOPER_DIR: /Applications/Xcode.app/Contents/Developer SDKROOT: /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk MACOSX_DEPLOYMENT_TARGET: 10.9 run: | rustup target add aarch64-apple-darwin rustup target add x86_64-apple-darwin pip install --upgrade maturin maturin build --release -o dist maturin build --release -o dist --target universal2-apple-darwin if: matrix.os == 'macos-latest' - name: Rename Wheels run: | python3 -c "import shutil; import glob; wheels = glob.glob('dist/*.whl'); [shutil.move(wheel, wheel.replace('py3', 'py2.py3')) for wheel in wheels if 'py2' not in wheel]" if: runner.os != 'Linux' - name: Upload Windows Wheels uses: actions/upload-artifact@v4 with: name: wheels-windows path: dist if: runner.os == 'Windows' - name: Upload Macos Wheels uses: actions/upload-artifact@v4 with: name: wheels-macos path: dist if: runner.os == 'macOS' build-linux-cross: runs-on: ubuntu-latest needs: [lint] strategy: fail-fast: false matrix: target: [ i686-unknown-linux-musl, armv7-unknown-linux-musleabihf, aarch64-unknown-linux-musl, x86_64-unknown-linux-musl, ] container: image: ghcr.io/benfred/rust-musl-cross:${{ matrix.target }} env: RUSTUP_HOME: /root/.rustup CARGO_HOME: /root/.cargo steps: - uses: actions/checkout@v5 - uses: Swatinem/rust-cache@v2 - name: Build run: | python3 -m pip install --upgrade maturin maturin build --release -o dist --target ${{ matrix.target }} --features unwind maturin sdist -o dist if: ${{ matrix.target == 'armv7-unknown-linux-musleabihf' || matrix.target == 'x86_64-unknown-linux-musl'}} - name: Build run: | python3 -m pip install --upgrade maturin maturin build --release -o dist --target ${{ matrix.target }} maturin sdist -o dist if: ${{ matrix.target == 'i686-unknown-linux-musl' || matrix.target == 'aarch64-unknown-linux-musl'}} - name: Rename Wheels run: | python3 -c "import shutil; import glob; wheels = glob.glob('dist/*.whl'); [shutil.move(wheel, wheel.replace('py3', 'py2.py3')) for wheel in wheels if 'py2' not in wheel]" - name: Upload wheels uses: actions/upload-artifact@v4 with: name: wheels-${{ matrix.target }} path: dist build-freebsd: runs-on: ubuntu-22.04 needs: [lint] timeout-minutes: 30 strategy: matrix: box: - freebsd-14 steps: - uses: actions/checkout@v5 - name: Display CPU info run: lscpu - name: Install VM tools run: | sudo apt-get update -qq sudo apt-get install -qq -o=Dpkg::Use-Pty=0 moreutils sudo chronic apt-get install -qq -o=Dpkg::Use-Pty=0 vagrant virtualbox qemu libvirt-daemon-system - name: Set up VM shell: sudo bash {0} run: | vagrant plugin install vagrant-libvirt vagrant plugin install vagrant-scp ln -sf ci/Vagrantfile Vagrantfile vagrant status vagrant up --no-tty --provider libvirt ${{ matrix.box }} - name: Build and test shell: sudo bash {0} run: vagrant ssh ${{ matrix.box }} -- bash /vagrant/ci/test_freebsd.sh - name: Retrieve build artifacts for caching purposes shell: sudo bash {0} run: | vagrant scp ${{ matrix.box }}:/vagrant/build-artifacts.tar build-artifacts.tar ls -ahl build-artifacts.tar - name: Prepare binary for upload run: | tar xf build-artifacts.tar target/release/py-spy mv target/release/py-spy py-spy-x86_64-unknown-freebsd - name: Upload Binaries uses: actions/upload-artifact@v4 with: name: py-spy-x86_64-unknown-freebsd path: py-spy-x86_64-unknown-freebsd test-wheels: name: Test Wheels needs: [build, build-linux-cross] runs-on: ${{ matrix.os }} strategy: fail-fast: false # automatically generated by ci/update_python_test_versions.py matrix: python-version: [ 3.6.7, 3.6.15, 3.7.1, 3.7.17, 3.8.0, 3.8.18, 3.9.0, 3.9.23, 3.10.0, 3.10.18, 3.11.0, 3.11.13, 3.12.0, 3.12.1, 3.12.2, 3.12.3, 3.12.4, 3.12.5, 3.12.6, 3.12.7, 3.12.8, 3.12.9, 3.12.10, 3.12.11, 3.13.0, 3.13.1, 3.13.2, 3.13.3, 3.13.4, 3.13.5, 3.13.6, 3.13.7, ] os: [ubuntu-22.04, macos-13, windows-latest, ubuntu-22.04-arm] # some versions of python can't be tested on GHA with osx because of SIP: exclude: - os: ubuntu-22.04 python-version: 3.6.7 - os: ubuntu-22.04-arm python-version: 3.6.7 - os: windows-latest python-version: 3.6.15 - os: ubuntu-22.04 python-version: 3.6.15 - os: ubuntu-22.04-arm python-version: 3.6.15 - os: ubuntu-22.04 python-version: 3.7.1 - os: ubuntu-22.04-arm python-version: 3.7.1 - os: windows-latest python-version: 3.7.17 - os: ubuntu-22.04-arm python-version: 3.7.17 - os: ubuntu-22.04 python-version: 3.8.0 - os: ubuntu-22.04-arm python-version: 3.8.0 - os: windows-latest python-version: 3.8.18 - os: ubuntu-22.04 python-version: 3.9.0 - os: ubuntu-22.04-arm python-version: 3.9.0 - os: windows-latest python-version: 3.9.23 - os: ubuntu-22.04 python-version: 3.10.0 - os: ubuntu-22.04-arm python-version: 3.10.0 - os: windows-latest python-version: 3.10.18 - os: macos-13 python-version: 3.11.13 - os: windows-latest python-version: 3.11.13 - os: macos-13 python-version: 3.12.0 - os: macos-13 python-version: 3.12.1 - os: macos-13 python-version: 3.12.2 - os: macos-13 python-version: 3.12.3 - os: macos-13 python-version: 3.12.4 - os: macos-13 python-version: 3.12.5 - os: macos-13 python-version: 3.12.6 - os: macos-13 python-version: 3.12.7 - os: macos-13 python-version: 3.12.8 - os: macos-13 python-version: 3.12.9 - os: macos-13 python-version: 3.12.10 - os: macos-13 python-version: 3.12.11 - os: windows-latest python-version: 3.12.11 steps: - uses: actions/checkout@v5 - uses: actions/download-artifact@v5 with: pattern: wheels-* merge-multiple: true - uses: actions/setup-python@v5 with: python-version: ${{ matrix.python-version }} - name: Install wheel run: | pip install --force-reinstall --no-index --find-links . py-spy - name: Test Wheel id: test run: python tests/integration_test.py if: runner.os != 'macOS' continue-on-error: true - name: Test Wheel (Retry#1) id: test1 run: python tests/integration_test.py if: steps.test.outcome=='failure' continue-on-error: true - name: Test Wheel (Retry#2) id: test2 run: python tests/integration_test.py if: steps.test1.outcome=='failure' - name: Test macOS Wheel id: osx_test run: sudo "PATH=$PATH" python tests/integration_test.py if: runner.os == 'macOS' continue-on-error: true - name: Test macOS Wheel (Retry#1) id: osx_test1 run: sudo "PATH=$PATH" python tests/integration_test.py if: steps.osx_test.outcome=='failure' continue-on-error: true - name: Test macOS Wheel (Retry#2) id: osx_test2 run: sudo "PATH=$PATH" python tests/integration_test.py if: steps.osx_test1.outcome=='failure' release: name: Release runs-on: ubuntu-latest if: "startsWith(github.ref, 'refs/tags/')" needs: [test-wheels] steps: - uses: actions/download-artifact@v5 with: pattern: wheels-* merge-multiple: true - name: Create GitHub Release uses: fnkr/github-action-ghr@v1.3 env: GHR_PATH: . GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} - name: Install Dependencies run: sudo apt install libunwind-dev if: runner.os == 'Linux' - uses: actions/setup-python@v5 with: python-version: 3.9 - name: Push to PyPi env: TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }} TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }} run: | pip install --upgrade wheel pip setuptools twine twine upload * rm * - uses: actions/checkout@v5 - name: Push to crates.io env: CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }} run: cargo publish ================================================ FILE: .github/workflows/release-drafter.yml ================================================ # draft release notes with https://github.com/release-drafter/release-drafter name: Release Drafter on: push: branches: - master workflow_dispatch: jobs: update_release_draft: runs-on: ubuntu-latest steps: # Drafts your next Release notes as Pull Requests are merged into "master" - uses: release-drafter/release-drafter@v6 env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} ================================================ FILE: .github/workflows/update_python_test.yml ================================================ name: Update Python Test Versions on: workflow_dispatch: schedule: - cron: "0 1 * * *" jobs: update-dep: runs-on: ubuntu-latest steps: - uses: actions/checkout@v5 with: ssh-key: ${{ secrets.SSH_PRIVATE_KEY }} - uses: actions/setup-python@v5 with: python-version: 3.9 - name: Install run: pip install --upgrade requests pyyaml - name: Scan for new python versions run: python ci/update_python_test_versions.py - name: Format results run: npx prettier --write ".github/workflows/update_python_test.yml" - name: Create Pull Request uses: peter-evans/create-pull-request@v7 with: commit-message: Update tested python versions title: Update tested python versions branch: update-python-versions labels: | skip-changelog dependencies ================================================ FILE: .gitignore ================================================ /target remoteprocess/target **/*.rs.bk # Python Distribution / packaging .Python env/ build/ develop-eggs/ dist/ downloads/ eggs/ .eggs/ lib/ lib64/ parts/ sdist/ var/ *.egg-info/ .installed.cfg *.egg .vscode/ **/.vagrant *.log ================================================ FILE: .pre-commit-config.yaml ================================================ repos: - repo: https://github.com/codespell-project/codespell rev: v2.2.4 hooks: - id: codespell additional_dependencies: [tomli] args: ["--toml", "pyproject.toml"] exclude: (?x)^(ci/testdata.*|images.*)$ - repo: https://github.com/doublify/pre-commit-rust rev: v1.0 hooks: - id: fmt - id: cargo-check - repo: https://github.com/rbubley/mirrors-prettier rev: v3.3.3 hooks: - id: prettier types: [yaml] ================================================ FILE: CHANGELOG.md ================================================ # Release notes are now being hosted in Github Releases: https://github.com/benfred/py-spy/releases ## v0.3.11 * Update dependencies [#463](https://github.com/benfred/py-spy/pull/463), [#457](https://github.com/benfred/py-spy/pull/463) * Warn about SYS_PTRACE when running in docker [#459](https://github.com/benfred/py-spy/pull/459) * Fix spelling mistakes [#453](https://github.com/benfred/py-spy/pull/453) ## v0.3.10 * Add support for profiling Python v3.10 [#425](https://github.com/benfred/py-spy/pull/425) * Fix issue with native profiling on Linux with Anaconda [#447](https://github.com/benfred/py-spy/pull/447) ## v0.3.9 * Add a subcommand to generate shell completions [#427](https://github.com/benfred/py-spy/issues/427) * Allow attaching co_firstlineno to frame name [#428](https://github.com/benfred/py-spy/issues/428) * Fix speedscope time interval [#434](https://github.com/benfred/py-spy/issues/434) * Fix profiling on FreeBSD [#431](https://github.com/benfred/py-spy/issues/431) * Use GitHub actions for FreeBSD CI [#433](https://github.com/benfred/py-spy/issues/433) ## v0.3.8 * Add wheels for Apple Silicon [#419](https://github.com/benfred/py-spy/issues/419) * Add --gil and --idle options to top view [#406](https://github.com/benfred/py-spy/issues/406) * Fix errors parsing python binaries [#407](https://github.com/benfred/py-spy/issues/407) * Specify timeunit in speedscope profiles [#294](https://github.com/benfred/py-spy/issues/294) ## v0.3.7 * Fix error that sometimes left the profiled program suspended [#390](https://github.com/benfred/py-spy/issues/390) * Documentation fixes for README [#391](https://github.com/benfred/py-spy/issues/391), [#393](https://github.com/benfred/py-spy/issues/393) ## v0.3.6 * Fix profiling inside a venv on windows [#216](https://github.com/benfred/py-spy/issues/216) * Detect GIL on Python 3.9.3+, 3.8.9+ [#375](https://github.com/benfred/py-spy/issues/375) * Fix getting thread names on python 3.9 [#387](https://github.com/benfred/py-spy/issues/387) * Fix getting thread names on ARMv7 [#388](https://github.com/benfred/py-spy/issues/388) * Add python integration tests, and test wheels across a range of different python versions [#378](https://github.com/benfred/py-spy/pull/378) * Automatically add tests for new versions of python [#379](https://github.com/benfred/py-spy/pull/379) ## v0.3.5 * Handle case where linux kernel is compiled without ```process_vm_readv``` support [#22](https://github.com/benfred/py-spy/issues/22) * Handle case where /proc/self/ns/mnt is missing [#326](https://github.com/benfred/py-spy/issues/326) * Allow attaching to processes where the python binary has been deleted [#109](https://github.com/benfred/py-spy/issues/109) * Make '--output' optional [#229](https://github.com/benfred/py-spy/issues/229) * Add --full-filenames to allow showing full Python filenames [#363](https://github.com/benfred/py-spy/issues/363) * Count "samples" as the number of recorded stacks (per thread) [#365](https://github.com/benfred/py-spy/issues/365) * Exit with an error if --gil but we failed to get necessary addrs/offsets [#361](https://github.com/benfred/py-spy/pull/361) * Include command/options used to run py-spy in flamegraph output [#293](https://github.com/benfred/py-spy/issues/293) * GIL Detection fixes for python 3.9.2/3.8.8 [#362](https://github.com/benfred/py-spy/pull/362) * Move to Github Actions for CI ## v0.3.4 * Build armv7/aarch64 wheels [#328](https://github.com/benfred/py-spy/issues/328) * Detect GIL on Python 3.9 / 3.7.7+ / 3.8.2+ * Add option for more verbose local variables [#287](https://github.com/benfred/py-spy/issues/287) * Fix issues with profiling subprocesses [#265](https://github.com/benfred/py-spy/issues/265) * Include python thread names in record [#237](https://github.com/benfred/py-spy/issues/237) * Fix issue with threadids triggering differential flamegraphs [#234](https://github.com/benfred/py-spy/issues/234) ## v0.3.3 * Change to display stdout/stderr from profiled child process [#217](https://github.com/benfred/py-spy/issues/217) * Fix memory leak on OSX [#227](https://github.com/benfred/py-spy/issues/227) * Fix panic on dump --locals [#224](https://github.com/benfred/py-spy/issues/224) * Fix cross container short filename generation [#220](https://github.com/benfred/py-spy/issues/220) ## v0.3.2 * Fix line numbers on python 3.8+ [#190](https://github.com/benfred/py-spy/issues/190) * Fix profiling pyinstaller binaries on OSX [#207](https://github.com/benfred/py-spy/issues/207) * Support getting GIL from Python 3.8.1/3.7.6/3.7.5 [#211](https://github.com/benfred/py-spy/issues/211) ## v0.3.1 * Fix ptrace errors on linux kernel older than v4.7 [#83](https://github.com/benfred/py-spy/issues/83) * Fix for profiling docker containers from host os [#199](https://github.com/benfred/py-spy/issues/199) * Fix for speedscope profiles aggregated by function name [#201](https://github.com/benfred/py-spy/issues/201) * Use symbols from dynsym table of ELF binaries [#191](https://github.com/benfred/py-spy/pull/191) ## v0.3.0 * Add ability to profile subprocesses [#124](https://github.com/benfred/py-spy/issues/124) * Fix overflow issue with linux symbolication [#183](https://github.com/benfred/py-spy/issues/183) * Fixes for printing local variables [#180](https://github.com/benfred/py-spy/pull/180) ## v0.2.2 * Add ability to show local variables when dumping out stack traces [#77](https://github.com/benfred/py-spy/issues/77) * Show python thread names in dump [#47](https://github.com/benfred/py-spy/issues/47) * Fix issues with profiling python hosted by .NET exe [#171](https://github.com/benfred/py-spy/issues/171) ## v0.2.1 * Fix issue with profiling dockerized process from the host os [#168](https://github.com/benfred/py-spy/issues/168) ## v0.2.0 * Add ability to profile native python extensions [#2](https://github.com/benfred/py-spy/issues/2) * Add FreeBSD support [#112](https://github.com/benfred/py-spy/issues/112) * Relicense to MIT [#163](https://github.com/benfred/py-spy/issues/163) * Add option to write out Speedscope files [#115](https://github.com/benfred/py-spy/issues/115) * Add option to output raw call stack data [#35](https://github.com/benfred/py-spy/issues/35) * Get thread idle status from OS [#92](https://github.com/benfred/py-spy/issues/92) * Add 'unlimited' default option for the duration [#93](https://github.com/benfred/py-spy/issues/93) * Allow use as a library by other rust programs [#110](https://github.com/benfred/py-spy/issues/110) * Show OS threadids in dump [#57](https://github.com/benfred/py-spy/issues/57) * Drop root permissions when starting new process [#116](https://github.com/benfred/py-spy/issues/116) * Support building for ARM processors [#89](https://github.com/benfred/py-spy/issues/89) * Python 3.8 compatibility * Fix issues profiling functions with more than 4000 lines [#164](https://github.com/benfred/py-spy/issues/164) ## v0.1.11 * Fix to detect GIL status on Python 3.7+ [#104](https://github.com/benfred/py-spy/pull/104) * Generate flamegraphs without perl (using Inferno) [#38](https://github.com/benfred/py-spy/issues/38) * Use irregular sampling interval to avoid incorrect results [#94](https://github.com/benfred/py-spy/issues/94) * Detect python packages when generating short filenames [#75](https://github.com/benfred/py-spy/issues/75) * Fix issue with finding interpreter with Python 3.7 and 32bit Linux [#101](https://github.com/benfred/py-spy/issues/101) * Detect "v2.7.15+" as a valid version string [#81](https://github.com/benfred/py-spy/issues/81) * Fix to cleanup venv after failing to build with setup.py [#69](https://github.com/benfred/py-spy/issues/69) ## v0.1.10 * Fix running py-spy inside a docker container [#68](https://github.com/benfred/py-spy/issues/68) ## v0.1.9 * Fix partial stack traces from showing up, by pausing process while collecting samples [#56](https://github.com/benfred/py-spy/issues/56). Also add a ```--nonblocking``` option to use previous behaviour of not stopping process. * Allow sampling process running in a docker container from the host OS [#49](https://github.com/benfred/py-spy/issues/49) * Allow collecting data for flame graph until interrupted with Control-C [#21](https://github.com/benfred/py-spy/issues/21) * Support 'legacy' strings in python 3 [#64](https://github.com/benfred/py-spy/issues/64) ## v0.1.8 * Support profiling pyinstaller binaries [#42](https://github.com/benfred/py-spy/issues/42) * Add fallback when failing to find exe in memory maps [#40](https://github.com/benfred/py-spy/issues/40) ## v0.1.7 * Console viewer improvements for Windows 7 [#37](https://github.com/benfred/py-spy/issues/37) ## v0.1.6 * Warn if we can't sample fast enough [#33](https://github.com/benfred/py-spy/issues/33) * Support embedded python interpreters like UWSGI [#25](https://github.com/benfred/py-spy/issues/25) * Better error message when failing with 32-bit python on windows ## v0.1.5 * Use musl libc for linux wheels [#5](https://github.com/benfred/py-spy/issues/5) * Fix for OSX python built with '--enable-framework' [#15](https://github.com/benfred/py-spy/issues/15) * Fix for running on Centos7 ## v0.1.4 * Initial public release ================================================ FILE: Cargo.toml ================================================ [features] unwind = ["remoteprocess/unwind"] [package] name = "py-spy" version = "0.4.1" authors = ["Ben Frederickson "] repository = "https://github.com/benfred/py-spy" homepage = "https://github.com/benfred/py-spy" description = "Sampling profiler for Python programs " readme = "README.md" exclude = ["images/*", "test_programs/*"] license = "MIT" build="build.rs" edition="2021" [dependencies] anyhow = "1" clap = {version="3.2", features=["wrap_help", "cargo", "derive"]} clap_complete="3.2" console = "0.16" ctrlc = "3" indicatif = "0.18" env_logger = "0.11" goblin = "0.10.0" inferno = "0.12.3" lazy_static = "1.4.0" libc = "0.2" log = "0.4" lru = "0.10" num-traits = "0.2" regex = ">=1.6.0" tempfile = "3.6.0" page_size = "0.6.0" proc-maps = "0.4.0" memmap2 = "0.9.4" cpp_demangle = "0.4" serde = {version="1.0", features=["rc"]} serde_derive = "1.0" serde_json = "1.0" rand = "0.8" rand_distr = "0.4" remoteprocess = "0.5.1" chrono = "0.4.26" [dev-dependencies] py-spy-testdata = "0.1.0" [target.'cfg(unix)'.dependencies] termios = "0.3.3" [target.'cfg(windows)'.dependencies] winapi = {version = "0.3", features = ["errhandlingapi", "winbase", "consoleapi", "wincon", "handleapi", "timeapi", "processenv" ]} ================================================ FILE: LICENSE ================================================ The MIT License (MIT) Copyright (c) 2018-2019 Ben Frederickson Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ================================================ FILE: README.md ================================================ py-spy: Sampling profiler for Python programs ===== [![Build Status](https://github.com/benfred/py-spy/workflows/Build/badge.svg?branch=master)](https://github.com/benfred/py-spy/actions?query=branch%3Amaster) [![FreeBSD Build Status](https://api.cirrus-ci.com/github/benfred/py-spy.svg)](https://cirrus-ci.com/github/benfred/py-spy) py-spy is a sampling profiler for Python programs. It lets you visualize what your Python program is spending time on without restarting the program or modifying the code in any way. py-spy is extremely low overhead: it is written in Rust for speed and doesn't run in the same process as the profiled Python program. This means py-spy is safe to use against production Python code. py-spy works on Linux, OSX, Windows and FreeBSD, and supports profiling all recent versions of the CPython interpreter (versions 2.3-2.7 and 3.3-3.13). ## Installation Prebuilt binary wheels can be installed from PyPI with: ``` pip install py-spy ``` You can also download prebuilt binaries from the [GitHub Releases Page](https://github.com/benfred/py-spy/releases). If you're a Rust user, py-spy can also be installed with: ```cargo install py-spy```. Note this builds py-spy from source and requires `libunwind` on Linux and Window, e.g., `apt install libunwind-dev`. On macOS, [py-spy is in Homebrew](https://formulae.brew.sh/formula/py-spy#default) and can be installed with ```brew install py-spy```. On Arch Linux, [py-spy is in AUR](https://aur.archlinux.org/packages/py-spy/) and can be installed with ```yay -S py-spy```. On Alpine Linux, [py-spy is in testing repository](https://pkgs.alpinelinux.org/packages?name=py-spy&branch=edge&repo=testing) and can be installed with ```apk add py-spy --update-cache --repository http://dl-3.alpinelinux.org/alpine/edge/testing/ --allow-untrusted```. ## Usage py-spy works from the command line and takes either the PID of the program you want to sample from or the command line of the python program you want to run. py-spy has three subcommands ```record```, ```top``` and ```dump```: ### record py-spy supports recording profiles to a file using the ```record``` command. For example, you can generate a [flame graph](http://www.brendangregg.com/flamegraphs.html) of your python process by going: ``` bash py-spy record -o profile.svg --pid 12345 # OR py-spy record -o profile.svg -- python myprogram.py ``` Which will generate an interactive SVG file looking like: ![flame graph](./images/flamegraph.svg) You can change the file format to generate [speedscope](https://github.com/jlfwong/speedscope) profiles or raw data with the ```--format``` parameter. See ```py-spy record --help``` for information on other options including changing the sampling rate, filtering to only include threads that hold the GIL, profiling native C extensions, showing thread-ids, profiling subprocesses and more. ### top Top shows a live view of what functions are taking the most time in your python program, similar to the Unix [top](https://linux.die.net/man/1/top) command. Running py-spy with: ``` bash py-spy top --pid 12345 # OR py-spy top -- python myprogram.py ``` will bring up a live updating high level view of your python program: ![console viewer demo](./images/console_viewer.gif) ### dump py-spy can also display the current call stack for each python thread with the ```dump``` command: ```bash py-spy dump --pid 12345 ``` This will dump out the call stacks for each thread, and some other basic process info to the console: ![dump output](./images/dump.png) This is useful for the case where you just need a single call stack to figure out where your python program is hung on. This command also has the ability to print out the local variables associated with each stack frame by setting the ```--locals``` flag. ## Frequently Asked Questions ### Why do we need another Python profiler? This project aims to let you profile and debug any running Python program, even if the program is serving production traffic. While there are many other python profiling projects, almost all of them require modifying the profiled program in some way. Usually, the profiling code runs inside of the target python process, which will slow down and change how the program operates. This means it's not generally safe to use these profilers for debugging issues in production services since they will usually have a noticeable impact on performance. ### How does py-spy work? py-spy works by directly reading the memory of the python program using the [process_vm_readv](http://man7.org/linux/man-pages/man2/process_vm_readv.2.html) system call on Linux, the [vm_read](https://developer.apple.com/documentation/kernel/1585350-vm_read?language=objc) call on OSX or the [ReadProcessMemory](https://msdn.microsoft.com/en-us/library/windows/desktop/ms680553(v=vs.85).aspx) call on Windows. Figuring out the call stack of the Python program is done by looking at the global PyInterpreterState variable to get all the Python threads running in the interpreter, and then iterating over each PyFrameObject in each thread to get the call stack. Since the Python ABI changes between versions, we use rust's [bindgen](https://github.com/rust-lang-nursery/rust-bindgen) to generate different rust structures for each Python interpreter class we care about and use these generated structs to figure out the memory layout in the Python program. Getting the memory address of the Python Interpreter can be a little tricky due to [Address Space Layout Randomization](https://en.wikipedia.org/wiki/Address_space_layout_randomization). If the target python interpreter ships with symbols it is pretty easy to figure out the memory address of the interpreter by dereferencing the ```interp_head``` or ```_PyRuntime``` variables depending on the Python version. However, many Python versions are shipped with either stripped binaries or shipped without the corresponding PDB symbol files on Windows. In these cases we scan through the BSS section for addresses that look like they may point to a valid PyInterpreterState and check if the layout of that address is what we expect. ### Can py-spy profile native extensions? Yes! py-spy supports profiling native python extensions written in languages like C/C++ or Cython, on some platforms (see table below). You can enable this mode by passing ```--native``` on the command line. For best results, you should compile your Python extension with symbols. Also worth noting for Cython programs is that py-spy needs the generated C or C++ file in order to return line numbers of the original .pyx file. Read the [blog post](https://www.benfrederickson.com/profiling-native-python-extensions-with-py-spy/) for more information. | | Linux | Windows | OSX | FreeBSD | |---------|-------|---------|-----|---------| | i686 | | | | | | x86-64 | yes | yes | | | | ARM | yes | | | | | Aarch64 | | | | | ### How can I profile subprocesses? By passing in the ```--subprocesses``` flag to either the record or top view, py-spy will also include the output from any python process that is a child process of the target program. This is useful for profiling applications that use multiprocessing or gunicorn worker pools. py-spy will monitor for new processes being created, and automatically attach to them and include samples from them in the output. The record view will include the PID and cmdline of each program in the callstack, with subprocesses appearing as children of their parent processes. ### When do you need to run as sudo? py-spy works by reading memory from a different python process, and this might not be allowed for security reasons depending on your OS and system settings. In many cases, running as a root user (with sudo or similar) gets around these security restrictions. OSX always requires running as root, but on Linux it depends on how you are launching py-spy and the system security settings. On Linux the default configuration is to require root permissions when attaching to a process that isn't a child. For py-spy this means you can profile without root access by getting py-spy to create the process (```py-spy record -- python myprogram.py```) but attaching to an existing process by specifying a PID will usually require root (```sudo py-spy record --pid 123456```). You can remove this restriction on Linux by setting the [ptrace_scope sysctl variable](https://wiki.ubuntu.com/SecurityTeam/Roadmap/KernelHardening#ptrace_Protection). ### How do you detect if a thread is idle or not? py-spy attempts to only include stack traces from threads that are actively running code, and exclude threads that are sleeping or otherwise idle. When possible, py-spy attempts to get this thread activity information from the OS: by reading in ```/proc/PID/stat``` on Linux, by using the mach [thread_basic_info](https://opensource.apple.com/source/xnu/xnu-792/osfmk/mach/thread_info.h.auto.html) call on OSX, and by looking if the current SysCall is [known to be idle](https://github.com/benfred/py-spy/blob/8326c6dbc6241d60125dfd4c01b70fed8b8b8138/remoteprocess/src/windows/mod.rs#L212-L229) on Windows. There are some limitations with this approach though that may cause idle threads to still be marked as active. First off, we have to get this thread activity information before pausing the program, because getting this from a paused program will cause it to always return that this is idle. This means there is a potential race condition, where we get the thread activity and then the thread is in a different state when we get the stack trace. Querying the OS for thread activity also isn't implemented yet for FreeBSD and i686/ARM processors on Linux. On Windows, calls that are blocked on IO also won't be marked as idle yet, for instance when reading input from stdin. Finally, on some Linux calls the ptrace attach that we are using may cause idle threads to wake up momentarily, causing false positives when reading from procfs. For these reasons, we also have a heuristic fallback that marks known certain known calls in python as being idle. You can disable this functionality by setting the ```--idle``` flag, which will include frames that py-spy considers idle. ### How does GIL detection work? We get GIL activity by looking at the threadid value pointed to by the ```_PyThreadState_Current``` symbol for Python 3.6 and earlier and by figuring out the equivalent from the ```_PyRuntime``` struct in Python 3.7 and later. These symbols might not be included in your python distribution, which will cause resolving which thread holds on to the GIL to fail. Current GIL usage is also shown in the ```top``` view as %GIL. Passing the ```--gil``` flag will only include traces for threads that are holding on to the [Global Interpreter Lock](https://wiki.python.org/moin/GlobalInterpreterLock). In some cases this might be a more accurate view of how your python program is spending its time, though you should be aware that this will miss activity in extensions that release the GIL while still active. ### Why am I having issues profiling /usr/bin/python on OSX? OSX has a feature called [System Integrity Protection](https://en.wikipedia.org/wiki/System_Integrity_Protection) that prevents even the root user from reading memory from any binary located in /usr/bin. Unfortunately, this includes the python interpreter that ships with OSX. There are a couple of different ways to deal with this: * You can install a different Python distribution. The built-in Python [will be removed](https://developer.apple.com/documentation/macos_release_notes/macos_catalina_10_15_release_notes) in a future OSX, and you probably want to migrate away from Python 2 anyways =). * You can use [virtualenv](https://virtualenv.pypa.io/en/stable/) to run the system python in an environment where SIP doesn't apply. * You can [disable System Integrity Protection](https://www.macworld.co.uk/how-to/mac/how-turn-off-mac-os-x-system-integrity-protection-rootless-3638975/). ### How do I run py-spy in Docker? Running py-spy inside of a docker container will also usually bring up a permissions denied error even when running as root. This error is caused by docker restricting the process_vm_readv system call we are using. This can be overridden by setting [```--cap-add SYS_PTRACE```](https://docs.docker.com/engine/security/seccomp/) when starting the docker container. Alternatively you can edit the docker-compose yaml file ``` your_service: cap_add: - SYS_PTRACE ``` Note that you'll need to restart the docker container in order for this setting to take effect. You can also use py-spy from the Host OS to profile a running process running inside the docker container. ### How do I run py-spy in Kubernetes? py-spy needs `SYS_PTRACE` to be able to read process memory. Kubernetes drops that capability by default, resulting in the error ``` Permission Denied: Try running again with elevated permissions by going 'sudo env "PATH=$PATH" !!' ``` The recommended way to deal with this is to edit the spec and add that capability. For a Deployment, this is done by adding this to `Deployment.spec.template.spec.containers` ``` securityContext: capabilities: add: - SYS_PTRACE ``` More details on this here: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/#set-capabilities-for-a-container Note that if you modify the Deployment resource, this will remove the existing Pods and create those again. You can also create an **ephemeral container** to attach to a running Pod, targeting a specific **container** where your application is running. Make sure to use a `profile` that grants the `SYS_PTRACE` permission, for example: ```sh kubectl debug --profile=general \ -n your-namespace \ --target=app-container-name \ pod-name \ --image=python:3.12-slim \ -it -- bash ``` ### How do I install py-spy on Alpine Linux? Alpine python opts out of the `manylinux` wheels: [pypa/pip#3969 (comment)](https://github.com/pypa/pip/issues/3969#issuecomment-247381915). You can override this behaviour to use pip to install py-spy on Alpine by going: echo 'manylinux1_compatible = True' > /usr/local/lib/python3.7/site-packages/_manylinux.py Alternatively you can download a musl binary from the [GitHub releases page](https://github.com/benfred/py-spy/releases). ### How can I avoid pausing the Python program? By setting the ```--nonblocking``` option, py-spy won't pause the target python you are profiling from. While the performance impact of sampling from a process with py-spy is usually extremely low, setting this option will totally avoid interrupting your running python program. With this option set, py-spy will instead read the interpreter state from the python process as it is running. Since the calls we use to read memory from are not atomic, and we have to issue multiple calls to get a stack trace this means that occasionally we get errors when sampling. This can show up as an increased error rate when sampling, or as partial stack frames being included in the output. ### Does py-spy support 32-bit Windows? Integrate with PyPy? Work with USC2 versions of Python2? Not yet =). If there are features you'd like to see in py-spy either thumb up the [appropriate issue](https://github.com/benfred/py-spy/issues?q=is%3Aissue+is%3Aopen+sort%3Areactions-%2B1-desc) or create a new one that describes what functionality is missing. ### How to force colored output when piping to a pager? py-spy follows the [CLICOLOR](https://bixense.com/clicolors/) specification, thus setting `CLICOLOR_FORCE=1` in your environment will have py-spy print colored output even when piped to a pager. ## Credits py-spy is heavily inspired by [Julia Evans](https://github.com/jvns/) excellent work on [rbspy](http://github.com/rbspy/rbspy). In particular, the code to generate flamegraph and speedscope files is taken directly from rbspy, and this project uses the [read-process-memory](https://github.com/luser/read-process-memory) and [proc-maps](https://github.com/benfred/proc-maps) crates that were spun off from rbspy. ## License py-spy is released under the MIT License, see the [LICENSE](https://github.com/benfred/py-spy/blob/master/LICENSE) file for the full text. ================================================ FILE: SECURITY.md ================================================ # Security Policy ## Reporting a Vulnerability Please email any security vulnerabilities to ben@benfrederickson.com. ## Supported Versions Only the most recent version of py-spy will get security updates. ================================================ FILE: build.rs ================================================ use std::env; fn main() { let target_arch = env::var("CARGO_CFG_TARGET_ARCH").unwrap(); let target_os = env::var("CARGO_CFG_TARGET_OS").unwrap(); match (target_arch.as_ref(), target_os.as_ref()) { ("x86_64", "windows") | ("x86_64", "linux") | ("arm", "linux") => { println!("cargo:rustc-cfg=unwind") } _ => {} } } ================================================ FILE: ci/Vagrantfile ================================================ Vagrant.configure("2") do |config| config.vm.define "freebsd-14" do |c| c.vm.box = "roboxes/freebsd14" end config.vm.boot_timeout = 600 config.vm.provider "libvirt" do |qe| # https://vagrant-libvirt.github.io/vagrant-libvirt/configuration.html qe.driver = "kvm" qe.cpus = 3 qe.memory = 8192 end config.vm.synced_folder ".", "/vagrant", type: "rsync", rsync__exclude: [".git", ".vagrant.d"] config.vm.provision "shell", inline: <<~SHELL set -e pkg install -y curl bash python llvm chsh -s /usr/local/bin/bash vagrant pw groupmod wheel -m vagrant su -l vagrant <<'EOF' curl https://sh.rustup.rs -sSf | sh -s -- -y --profile minimal --default-toolchain 1.88.0 EOF SHELL end ================================================ FILE: ci/publish_freebsd.sh ================================================ #!/usr/bin/env bash set -ex if [[ "$CIRRUS_RELEASE" == "" ]]; then echo "Not a release. No need to deploy!" exit 0 fi if [[ "$GITHUB_TOKEN" == "" ]]; then echo "Please provide GitHub access token via GITHUB_TOKEN environment variable!" exit 1 fi file_content_type="application/octet-stream" fpath=py-spy-$CIRRUS_TAG-x86_64-freebsd.tar.gz tar -C ./target/release -czf $fpath py-spy echo "Uploading $fpath..." name=$(basename "$fpath") url_to_upload="https://uploads.github.com/repos/$CIRRUS_REPO_FULL_NAME/releases/$CIRRUS_RELEASE/assets?name=$name" curl -X POST \ --data-binary @$fpath \ --header "Authorization: token $GITHUB_TOKEN" \ --header "Content-Type: $file_content_type" \ $url_to_upload ================================================ FILE: ci/test_freebsd.sh ================================================ #!/usr/bin/env bash source "$HOME/.cargo/env" set -e python --version cargo --version cd /vagrant if [ -f build-artifacts.tar ]; then echo "Unpacking cached build artifacts..." tar xf build-artifacts.tar rm -f build-artifacts.tar fi cargo build --release --workspace --all-targets # TODO: re-enable integration tests # cargo test --release set +e tar cf build-artifacts.tar target tar rf build-artifacts.tar "$HOME/.cargo/git" tar rf build-artifacts.tar "$HOME/.cargo/registry" exit 0 ================================================ FILE: ci/testdata/cython_test.c ================================================ /* Generated by Cython 0.28.5 */ #define PY_SSIZE_T_CLEAN #include "Python.h" #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. #elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) #error Cython requires Python 2.6+ or Python 3.3+. #else #define CYTHON_ABI "0_28_5" #define CYTHON_FUTURE_DIVISION 0 #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif #if !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif #ifndef __cdecl #define __cdecl #endif #ifndef __fastcall #define __fastcall #endif #endif #ifndef DL_IMPORT #define DL_IMPORT(t) t #endif #ifndef DL_EXPORT #define DL_EXPORT(t) t #endif #define __PYX_COMMA , #ifndef HAVE_LONG_LONG #if PY_VERSION_HEX >= 0x02070000 #define HAVE_LONG_LONG #endif #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG #endif #ifndef Py_HUGE_VAL #define Py_HUGE_VAL HUGE_VAL #endif #ifdef PYPY_VERSION #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #if PY_VERSION_HEX < 0x03050000 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #undef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 0 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #undef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 1 #undef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 0 #undef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #elif defined(PYSTON_VERSION) #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 1 #define CYTHON_COMPILING_IN_CPYTHON 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #else #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 1 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #if PY_VERSION_HEX < 0x02070000 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif #if PY_MAJOR_VERSION < 3 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #if PY_VERSION_HEX < 0x02070000 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #elif !defined(CYTHON_USE_PYLONG_INTERNALS) #define CYTHON_USE_PYLONG_INTERNALS 1 #endif #ifndef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 1 #endif #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #if PY_VERSION_HEX < 0x030300F0 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #elif !defined(CYTHON_USE_UNICODE_WRITER) #define CYTHON_USE_UNICODE_WRITER 1 #endif #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #ifndef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 1 #endif #ifndef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 1 #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT (0 && PY_VERSION_HEX >= 0x03050000) #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) #endif #endif #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif #if CYTHON_USE_PYLONG_INTERNALS #include "longintrepr.h" #undef SHIFT #undef BASE #undef MASK #endif #ifndef __has_attribute #define __has_attribute(x) 0 #endif #ifndef __has_cpp_attribute #define __has_cpp_attribute(x) 0 #endif #ifndef CYTHON_RESTRICT #if defined(__GNUC__) #define CYTHON_RESTRICT __restrict__ #elif defined(_MSC_VER) && _MSC_VER >= 1400 #define CYTHON_RESTRICT __restrict #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_RESTRICT restrict #else #define CYTHON_RESTRICT #endif #endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif # elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif #endif #ifndef CYTHON_MAYBE_UNUSED_VAR # if defined(__cplusplus) template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } # else # define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) # endif #endif #ifndef CYTHON_NCP_UNUSED # if CYTHON_COMPILING_IN_CPYTHON # define CYTHON_NCP_UNUSED # else # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) #ifdef _MSC_VER #ifndef _MSC_STDINT_H_ #if _MSC_VER < 1300 typedef unsigned char uint8_t; typedef unsigned int uint32_t; #else typedef unsigned __int8 uint8_t; typedef unsigned __int32 uint32_t; #endif #endif #else #include #endif #ifndef CYTHON_FALLTHROUGH #if defined(__cplusplus) && __cplusplus >= 201103L #if __has_cpp_attribute(fallthrough) #define CYTHON_FALLTHROUGH [[fallthrough]] #elif __has_cpp_attribute(clang::fallthrough) #define CYTHON_FALLTHROUGH [[clang::fallthrough]] #elif __has_cpp_attribute(gnu::fallthrough) #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] #endif #endif #ifndef CYTHON_FALLTHROUGH #if __has_attribute(fallthrough) #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) #else #define CYTHON_FALLTHROUGH #endif #endif #if defined(__clang__ ) && defined(__apple_build_version__) #if __apple_build_version__ < 7000000 #undef CYTHON_FALLTHROUGH #define CYTHON_FALLTHROUGH #endif #endif #endif #ifndef CYTHON_INLINE #if defined(__clang__) #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) #elif defined(__GNUC__) #define CYTHON_INLINE __inline__ #elif defined(_MSC_VER) #define CYTHON_INLINE __inline #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_INLINE inline #else #define CYTHON_INLINE #endif #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) #define Py_OptimizeFlag 0 #endif #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyClass_Type #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyType_Type #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 #endif #ifndef Py_TPFLAGS_HAVE_INDEX #define Py_TPFLAGS_HAVE_INDEX 0 #endif #ifndef Py_TPFLAGS_HAVE_NEWBUFFER #define Py_TPFLAGS_HAVE_NEWBUFFER 0 #endif #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif #if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) #ifndef METH_FASTCALL #define METH_FASTCALL 0x80 #endif typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); #else #define __Pyx_PyCFunctionFast _PyCFunctionFast #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords #endif #if CYTHON_FAST_PYCCALL #define __Pyx_PyFastCFunction_Check(func)\ ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS))))) #else #define __Pyx_PyFastCFunction_Check(func) 0 #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) #define PyObject_Malloc(s) PyMem_Malloc(s) #define PyObject_Free(p) PyMem_Free(p) #define PyObject_Realloc(p) PyMem_Realloc(p) #endif #if CYTHON_COMPILING_IN_PYSTON #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) #else #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) #endif #if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #elif PY_VERSION_HEX >= 0x03060000 #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #elif PY_VERSION_HEX >= 0x03000000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #else #define __Pyx_PyThreadState_Current _PyThreadState_Current #endif #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) #include "pythread.h" #define Py_tss_NEEDS_INIT 0 typedef int Py_tss_t; static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { *key = PyThread_create_key(); return 0; // PyThread_create_key reports success always } static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); *key = Py_tss_NEEDS_INIT; return key; } static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { PyObject_Free(key); } static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { return *key != Py_tss_NEEDS_INIT; } static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { PyThread_delete_key(*key); *key = Py_tss_NEEDS_INIT; } static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { return PyThread_set_key_value(*key, value); } static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { return PyThread_get_key_value(*key); } #endif // TSS (Thread Specific Storage) API #if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else #define __Pyx_PyDict_NewPresized(n) PyDict_New() #endif #if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) #else #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS #define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) #else #define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) #endif #if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) #define CYTHON_PEP393_ENABLED 1 #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ 0 : _PyUnicode_Ready((PyObject *)(op))) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) #else #define CYTHON_PEP393_ENABLED 0 #define PyUnicode_1BYTE_KIND 1 #define PyUnicode_2BYTE_KIND 2 #define PyUnicode_4BYTE_KIND 4 #define __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) #endif #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) #else #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) #endif #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) #else #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) #endif #if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) #define PyObject_ASCII(o) PyObject_Repr(o) #endif #if PY_MAJOR_VERSION >= 3 #define PyBaseString_Type PyUnicode_Type #define PyStringObject PyUnicodeObject #define PyString_Type PyUnicode_Type #define PyString_Check PyUnicode_Check #define PyString_CheckExact PyUnicode_CheckExact #define PyObject_Unicode PyObject_Str #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) #else #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif #ifndef PySet_CheckExact #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) #endif #if CYTHON_ASSUME_SAFE_MACROS #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) #else #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) #endif #if PY_MAJOR_VERSION >= 3 #define PyIntObject PyLongObject #define PyInt_Type PyLong_Type #define PyInt_Check(op) PyLong_Check(op) #define PyInt_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong #define PyInt_FromSize_t PyLong_FromSize_t #define PyInt_FromSsize_t PyLong_FromSsize_t #define PyInt_AsLong PyLong_AsLong #define PyInt_AS_LONG PyLong_AS_LONG #define PyInt_AsSsize_t PyLong_AsSsize_t #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject #endif #if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY #ifndef PyUnicode_InternFromString #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) #endif #endif #if PY_VERSION_HEX < 0x030200A4 typedef long Py_hash_t; #define __Pyx_PyInt_FromHash_t PyInt_FromLong #define __Pyx_PyInt_AsHash_t PyInt_AsLong #else #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : (Py_INCREF(func), func)) #else #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) #endif #if CYTHON_USE_ASYNC_SLOTS #if PY_VERSION_HEX >= 0x030500B1 #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) #else #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) #endif #else #define __Pyx_PyType_AsAsync(obj) NULL #endif #ifndef __Pyx_PyAsyncMethodsStruct typedef struct { unaryfunc am_await; unaryfunc am_aiter; unaryfunc am_anext; } __Pyx_PyAsyncMethodsStruct; #endif #if defined(WIN32) || defined(MS_WINDOWS) #define _USE_MATH_DEFINES #endif #include #ifdef NAN #define __PYX_NAN() ((float) NAN) #else static CYTHON_INLINE float __PYX_NAN() { float value; memset(&value, 0xFF, sizeof(value)); return value; } #endif #if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) #define __Pyx_truncl trunc #else #define __Pyx_truncl truncl #endif #define __PYX_ERR(f_index, lineno, Ln_error) \ { \ __pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; goto Ln_error; \ } #ifndef __PYX_EXTERN_C #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else #define __PYX_EXTERN_C extern #endif #endif #define __PYX_HAVE__cython_test #define __PYX_HAVE_API__cython_test /* Early includes */ #ifdef _OPENMP #include #endif /* _OPENMP */ #if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) #define CYTHON_WITHOUT_ASSERTIONS #endif typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; #define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0 #define __PYX_DEFAULT_STRING_ENCODING "" #define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString #define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #define __Pyx_uchar_cast(c) ((unsigned char)c) #define __Pyx_long_cast(x) ((long)x) #define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ (sizeof(type) < sizeof(Py_ssize_t)) ||\ (sizeof(type) > sizeof(Py_ssize_t) &&\ likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX) &&\ (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ v == (type)PY_SSIZE_T_MIN))) ||\ (sizeof(type) == sizeof(Py_ssize_t) &&\ (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX))) ) #if defined (__cplusplus) && __cplusplus >= 201103L #include #define __Pyx_sst_abs(value) std::abs(value) #elif SIZEOF_INT >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) abs(value) #elif SIZEOF_LONG >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) labs(value) #elif defined (_MSC_VER) #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define __Pyx_sst_abs(value) llabs(value) #elif defined (__GNUC__) #define __Pyx_sst_abs(value) __builtin_llabs(value) #else #define __Pyx_sst_abs(value) ((value<0) ? -value : value) #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); #define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #if PY_MAJOR_VERSION < 3 #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #else #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize #endif #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) #define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) #define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) #define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { const Py_UNICODE *u_end = u; while (*u_end++) ; return (size_t)(u_end - u - 1); } #define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) #define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); #define __Pyx_PySequence_Tuple(obj)\ (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); #if CYTHON_ASSUME_SAFE_MACROS #define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) #else #define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) #endif #define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) #else #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) #endif #define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII static int __Pyx_sys_getdefaultencoding_not_ascii; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; PyObject* ascii_chars_u = NULL; PyObject* ascii_chars_b = NULL; const char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; if (strcmp(default_encoding_c, "ascii") == 0) { __Pyx_sys_getdefaultencoding_not_ascii = 0; } else { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { ascii_chars[c] = c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); if (!ascii_chars_u) goto bad; ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { PyErr_Format( PyExc_ValueError, "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", default_encoding_c); goto bad; } Py_DECREF(ascii_chars_u); Py_DECREF(ascii_chars_b); } Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); Py_XDECREF(ascii_chars_u); Py_XDECREF(ascii_chars_b); return -1; } #endif #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) #else #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c)); if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); return -1; } #endif #endif /* Test for GCC > 2.95 */ #if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #else /* !__GNUC__ or GCC < 2.95 */ #define likely(x) (x) #define unlikely(x) (x) #endif /* __GNUC__ */ static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } static PyObject *__pyx_m = NULL; static PyObject *__pyx_d; static PyObject *__pyx_b; static PyObject *__pyx_cython_runtime = NULL; static PyObject *__pyx_empty_tuple; static PyObject *__pyx_empty_bytes; static PyObject *__pyx_empty_unicode; static int __pyx_lineno; static int __pyx_clineno = 0; static const char * __pyx_cfilenm= __FILE__; static const char *__pyx_filename; static const char *__pyx_f[] = { "cython_test.pyx", }; /*--- Type declarations ---*/ /* --- Runtime support code (head) --- */ /* Refnanny.proto */ #ifndef CYTHON_REFNANNY #define CYTHON_REFNANNY 0 #endif #if CYTHON_REFNANNY typedef struct { void (*INCREF)(void*, PyObject*, int); void (*DECREF)(void*, PyObject*, int); void (*GOTREF)(void*, PyObject*, int); void (*GIVEREF)(void*, PyObject*, int); void* (*SetupContext)(const char*, int, const char*); void (*FinishContext)(void**); } __Pyx_RefNannyAPIStruct; static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; #ifdef WITH_THREAD #define __Pyx_RefNannySetupContext(name, acquire_gil)\ if (acquire_gil) {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ PyGILState_Release(__pyx_gilstate_save);\ } else {\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil)\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) #endif #define __Pyx_RefNannyFinishContext()\ __Pyx_RefNanny->FinishContext(&__pyx_refnanny) #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) #define __Pyx_GOTREF(r) #define __Pyx_GIVEREF(r) #define __Pyx_XINCREF(r) Py_XINCREF(r) #define __Pyx_XDECREF(r) Py_XDECREF(r) #define __Pyx_XGOTREF(r) #define __Pyx_XGIVEREF(r) #endif #define __Pyx_XDECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_XDECREF(tmp);\ } while (0) #define __Pyx_DECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_DECREF(tmp);\ } while (0) #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) /* PyObjectGetAttrStr.proto */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) #endif /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); /* RaiseArgTupleInvalid.proto */ static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); /* RaiseDoubleKeywords.proto */ static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); /* ParseKeywords.proto */ static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ const char* function_name); /* GetItemInt.proto */ #define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ __Pyx_GetItemInt_Generic(o, to_py_func(i)))) #define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck); #define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck); static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, int wraparound, int boundscheck); /* PyDictContains.proto */ static CYTHON_INLINE int __Pyx_PyDict_ContainsTF(PyObject* item, PyObject* dict, int eq) { int result = PyDict_Contains(dict, item); return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); } /* DictGetItem.proto */ #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key); #define __Pyx_PyObject_Dict_GetItem(obj, name)\ (likely(PyDict_CheckExact(obj)) ?\ __Pyx_PyDict_GetItem(obj, name) : PyObject_GetItem(obj, name)) #else #define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) #define __Pyx_PyObject_Dict_GetItem(obj, name) PyObject_GetItem(obj, name) #endif /* PyCFunctionFastCall.proto */ #if CYTHON_FAST_PYCCALL static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); #else #define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) #endif /* PyFunctionFastCall.proto */ #if CYTHON_FAST_PYCALL #define __Pyx_PyFunction_FastCall(func, args, nargs)\ __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) #if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs); #else #define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) #endif #endif /* PyObjectCall.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); #else #define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) #endif /* PyObjectCallMethO.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif /* PyObjectCallOneArg.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); /* PyThreadStateGet.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; #define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; #define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type #else #define __Pyx_PyThreadState_declare #define __Pyx_PyThreadState_assign #define __Pyx_PyErr_Occurred() PyErr_Occurred() #endif /* PyErrFetchRestore.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) #define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) #define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) #else #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #endif #else #define __Pyx_PyErr_Clear() PyErr_Clear() #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) #endif /* RaiseException.proto */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); /* SetItemInt.proto */ #define __Pyx_SetItemInt(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_SetItemInt_Fast(o, (Py_ssize_t)i, v, is_list, wraparound, boundscheck) :\ (is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) :\ __Pyx_SetItemInt_Generic(o, to_py_func(i), v))) static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v); static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, int is_list, int wraparound, int boundscheck); /* IterFinish.proto */ static CYTHON_INLINE int __Pyx_IterFinish(void); /* PyObjectCallNoArg.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); #else #define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) #endif /* PyObjectCallMethod0.proto */ static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); /* RaiseNeedMoreValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); /* RaiseTooManyValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); /* UnpackItemEndCheck.proto */ static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); /* RaiseNoneIterError.proto */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); /* UnpackTupleError.proto */ static void __Pyx_UnpackTupleError(PyObject *, Py_ssize_t index); /* UnpackTuple2.proto */ #define __Pyx_unpack_tuple2(tuple, value1, value2, is_tuple, has_known_size, decref_tuple)\ (likely(is_tuple || PyTuple_Check(tuple)) ?\ (likely(has_known_size || PyTuple_GET_SIZE(tuple) == 2) ?\ __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple) :\ (__Pyx_UnpackTupleError(tuple, 2), -1)) :\ __Pyx_unpack_tuple2_generic(tuple, value1, value2, has_known_size, decref_tuple)) static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( PyObject* tuple, PyObject** value1, PyObject** value2, int decref_tuple); static int __Pyx_unpack_tuple2_generic( PyObject* tuple, PyObject** value1, PyObject** value2, int has_known_size, int decref_tuple); /* dict_iter.proto */ static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* dict, int is_dict, PyObject* method_name, Py_ssize_t* p_orig_length, int* p_is_dict); static CYTHON_INLINE int __Pyx_dict_iter_next(PyObject* dict_or_iter, Py_ssize_t orig_length, Py_ssize_t* ppos, PyObject** pkey, PyObject** pvalue, PyObject** pitem, int is_dict); /* ListAppend.proto */ #if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { PyListObject* L = (PyListObject*) list; Py_ssize_t len = Py_SIZE(list); if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) { Py_INCREF(x); PyList_SET_ITEM(list, len, x); Py_SIZE(list) = len+1; return 0; } return PyList_Append(list, x); } #else #define __Pyx_PyList_Append(L,x) PyList_Append(L,x) #endif /* FetchCommonType.proto */ static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); /* CythonFunction.proto */ #define __Pyx_CyFunction_USED 1 #define __Pyx_CYFUNCTION_STATICMETHOD 0x01 #define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 #define __Pyx_CYFUNCTION_CCLASS 0x04 #define __Pyx_CyFunction_GetClosure(f)\ (((__pyx_CyFunctionObject *) (f))->func_closure) #define __Pyx_CyFunction_GetClassObj(f)\ (((__pyx_CyFunctionObject *) (f))->func_classobj) #define __Pyx_CyFunction_Defaults(type, f)\ ((type *)(((__pyx_CyFunctionObject *) (f))->defaults)) #define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g) typedef struct { PyCFunctionObject func; #if PY_VERSION_HEX < 0x030500A0 PyObject *func_weakreflist; #endif PyObject *func_dict; PyObject *func_name; PyObject *func_qualname; PyObject *func_doc; PyObject *func_globals; PyObject *func_code; PyObject *func_closure; PyObject *func_classobj; void *defaults; int defaults_pyobjects; int flags; PyObject *defaults_tuple; PyObject *defaults_kwdict; PyObject *(*defaults_getter)(PyObject *); PyObject *func_annotations; } __pyx_CyFunctionObject; static PyTypeObject *__pyx_CyFunctionType = 0; #define __Pyx_CyFunction_NewEx(ml, flags, qualname, self, module, globals, code)\ __Pyx_CyFunction_New(__pyx_CyFunctionType, ml, flags, qualname, self, module, globals, code) static PyObject *__Pyx_CyFunction_New(PyTypeObject *, PyMethodDef *ml, int flags, PyObject* qualname, PyObject *self, PyObject *module, PyObject *globals, PyObject* code); static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m, size_t size, int pyobjects); static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, PyObject *tuple); static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, PyObject *dict); static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, PyObject *dict); static int __pyx_CyFunction_init(void); /* FusedFunction.proto */ typedef struct { __pyx_CyFunctionObject func; PyObject *__signatures__; PyObject *type; PyObject *self; } __pyx_FusedFunctionObject; #define __pyx_FusedFunction_NewEx(ml, flags, qualname, self, module, globals, code)\ __pyx_FusedFunction_New(__pyx_FusedFunctionType, ml, flags, qualname, self, module, globals, code) static PyObject *__pyx_FusedFunction_New(PyTypeObject *type, PyMethodDef *ml, int flags, PyObject *qualname, PyObject *self, PyObject *module, PyObject *globals, PyObject *code); static int __pyx_FusedFunction_clear(__pyx_FusedFunctionObject *self); static PyTypeObject *__pyx_FusedFunctionType = NULL; static int __pyx_FusedFunction_init(void); #define __Pyx_FusedFunction_USED /* CLineInTraceback.proto */ #ifdef CYTHON_CLINE_IN_TRACEBACK #define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) #else static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #endif /* CodeObjectCache.proto */ typedef struct { PyCodeObject* code_object; int code_line; } __Pyx_CodeObjectCacheEntry; struct __Pyx_CodeObjectCache { int count; int max_count; __Pyx_CodeObjectCacheEntry* entries; }; static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); static PyCodeObject *__pyx_find_code_object(int code_line); static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); /* AddTraceback.proto */ static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); /* Import.proto */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); /* CIntFromPy.proto */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); /* ImportNumPyArray.proto */ static PyObject *__pyx_numpy_ndarray = NULL; static PyObject* __Pyx_ImportNumPyArrayTypeIfAvailable(void); /* CIntFromPy.proto */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); #else #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) #endif #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) /* CheckBinaryVersion.proto */ static int __Pyx_check_binary_version(void); /* InitStrings.proto */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); /* Module declarations from 'cython' */ /* Module declarations from 'cython_test' */ static PyObject *__pyx_fuse_0__pyx_f_11cython_test_sqrt(float, int __pyx_skip_dispatch); /*proto*/ static PyObject *__pyx_fuse_1__pyx_f_11cython_test_sqrt(double, int __pyx_skip_dispatch); /*proto*/ #define __Pyx_MODULE_NAME "cython_test" extern int __pyx_module_is_main_cython_test; int __pyx_module_is_main_cython_test = 0; /* Implementation of 'cython_test' */ static PyObject *__pyx_builtin_TypeError; static PyObject *__pyx_builtin_range; static const char __pyx_k_[] = ""; static const char __pyx_k__2[] = "()"; static const char __pyx_k__4[] = "|"; static const char __pyx_k_args[] = "args"; static const char __pyx_k_main[] = "__main__"; static const char __pyx_k_name[] = "__name__"; static const char __pyx_k_sqrt[] = "sqrt"; static const char __pyx_k_test[] = "__test__"; static const char __pyx_k_float[] = "float"; static const char __pyx_k_numpy[] = "numpy"; static const char __pyx_k_range[] = "range"; static const char __pyx_k_split[] = "split"; static const char __pyx_k_strip[] = "strip"; static const char __pyx_k_value[] = "value"; static const char __pyx_k_double[] = "double"; static const char __pyx_k_import[] = "__import__"; static const char __pyx_k_kwargs[] = "kwargs"; static const char __pyx_k_defaults[] = "defaults"; static const char __pyx_k_TypeError[] = "TypeError"; static const char __pyx_k_signatures[] = "signatures"; static const char __pyx_k_cython_test[] = "cython_test"; static const char __pyx_k_pyx_fuse_0sqrt[] = "__pyx_fuse_0sqrt"; static const char __pyx_k_pyx_fuse_1sqrt[] = "__pyx_fuse_1sqrt"; static const char __pyx_k_cython_test_pyx[] = "cython_test.pyx"; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; static const char __pyx_k_No_matching_signature_found[] = "No matching signature found"; static const char __pyx_k_simple_test_file_for_cython_sou[] = " simple test file for cython source mapping: defines a function\nthat uses newtowns method to compute the square root of a number "; static const char __pyx_k_Expected_at_least_d_argument_s_g[] = "Expected at least %d argument%s, got %d"; static const char __pyx_k_Function_call_with_ambiguous_arg[] = "Function call with ambiguous argument types"; static PyObject *__pyx_kp_s_; static PyObject *__pyx_kp_s_Expected_at_least_d_argument_s_g; static PyObject *__pyx_kp_s_Function_call_with_ambiguous_arg; static PyObject *__pyx_kp_s_No_matching_signature_found; static PyObject *__pyx_n_s_TypeError; static PyObject *__pyx_kp_s__2; static PyObject *__pyx_kp_s__4; static PyObject *__pyx_n_s_args; static PyObject *__pyx_n_s_cline_in_traceback; static PyObject *__pyx_n_s_cython_test; static PyObject *__pyx_kp_s_cython_test_pyx; static PyObject *__pyx_n_s_defaults; static PyObject *__pyx_n_s_double; static PyObject *__pyx_n_s_float; static PyObject *__pyx_n_s_import; static PyObject *__pyx_n_s_kwargs; static PyObject *__pyx_n_s_main; static PyObject *__pyx_n_s_name; static PyObject *__pyx_n_s_numpy; static PyObject *__pyx_n_s_pyx_fuse_0sqrt; static PyObject *__pyx_n_s_pyx_fuse_1sqrt; static PyObject *__pyx_n_s_range; static PyObject *__pyx_n_s_signatures; static PyObject *__pyx_n_s_split; static PyObject *__pyx_n_s_sqrt; static PyObject *__pyx_n_s_strip; static PyObject *__pyx_n_s_test; static PyObject *__pyx_n_s_value; static PyObject *__pyx_pf_11cython_test_sqrt(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_signatures, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs, CYTHON_UNUSED PyObject *__pyx_v_defaults); /* proto */ static PyObject *__pyx_pf_11cython_test_2__pyx_fuse_0sqrt(CYTHON_UNUSED PyObject *__pyx_self, float __pyx_v_value); /* proto */ static PyObject *__pyx_pf_11cython_test_4__pyx_fuse_1sqrt(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_value); /* proto */ static PyObject *__pyx_int_1; static PyObject *__pyx_tuple__3; static PyObject *__pyx_tuple__5; static PyObject *__pyx_tuple__6; static PyObject *__pyx_tuple__7; static PyObject *__pyx_tuple__8; static PyObject *__pyx_codeobj__9; /* Late includes */ /* "cython_test.pyx":6 * from cython cimport floating * * cpdef sqrt(floating value): # <<<<<<<<<<<<<< * # solve for the square root of value by finding the zeros of * # 'x * x - value = 0' using newtons meethod */ /* Python wrapper */ static PyObject *__pyx_pw_11cython_test_1sqrt(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_mdef_11cython_test_1sqrt = {"sqrt", (PyCFunction)__pyx_pw_11cython_test_1sqrt, METH_VARARGS|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_11cython_test_1sqrt(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_signatures = 0; PyObject *__pyx_v_args = 0; PyObject *__pyx_v_kwargs = 0; CYTHON_UNUSED PyObject *__pyx_v_defaults = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__pyx_fused_cpdef (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_signatures,&__pyx_n_s_args,&__pyx_n_s_kwargs,&__pyx_n_s_defaults,0}; PyObject* values[4] = {0,0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_signatures)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_args)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, 1); __PYX_ERR(0, 6, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_kwargs)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, 2); __PYX_ERR(0, 6, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_defaults)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, 3); __PYX_ERR(0, 6, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_fused_cpdef") < 0)) __PYX_ERR(0, 6, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 4) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); values[3] = PyTuple_GET_ITEM(__pyx_args, 3); } __pyx_v_signatures = values[0]; __pyx_v_args = values[1]; __pyx_v_kwargs = values[2]; __pyx_v_defaults = values[3]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 6, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("cython_test.__pyx_fused_cpdef", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_11cython_test_sqrt(__pyx_self, __pyx_v_signatures, __pyx_v_args, __pyx_v_kwargs, __pyx_v_defaults); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_11cython_test_sqrt(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_signatures, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs, CYTHON_UNUSED PyObject *__pyx_v_defaults) { PyObject *__pyx_v_dest_sig = NULL; Py_ssize_t __pyx_v_i; CYTHON_UNUSED PyTypeObject *__pyx_v_ndarray = 0; CYTHON_UNUSED Py_ssize_t __pyx_v_itemsize; PyObject *__pyx_v_arg = NULL; PyObject *__pyx_v_candidates = NULL; PyObject *__pyx_v_sig = NULL; int __pyx_v_match_found; PyObject *__pyx_v_src_sig = NULL; PyObject *__pyx_v_dst_type = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; int __pyx_t_4; Py_ssize_t __pyx_t_5; PyObject *__pyx_t_6 = NULL; Py_ssize_t __pyx_t_7; int __pyx_t_8; int __pyx_t_9; PyObject *__pyx_t_10 = NULL; Py_ssize_t __pyx_t_11; Py_ssize_t __pyx_t_12; Py_ssize_t __pyx_t_13; int __pyx_t_14; __Pyx_RefNannySetupContext("sqrt", 0); __Pyx_INCREF(__pyx_v_kwargs); __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyList_SET_ITEM(__pyx_t_1, 0, Py_None); __pyx_v_dest_sig = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_v_kwargs != Py_None); __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { } else { __pyx_t_2 = __pyx_t_4; goto __pyx_L4_bool_binop_done; } __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_kwargs); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 6, __pyx_L1_error) __pyx_t_3 = ((!__pyx_t_4) != 0); __pyx_t_2 = __pyx_t_3; __pyx_L4_bool_binop_done:; if (__pyx_t_2) { __Pyx_INCREF(Py_None); __Pyx_DECREF_SET(__pyx_v_kwargs, Py_None); } __pyx_t_1 = ((PyObject *)__Pyx_ImportNumPyArrayTypeIfAvailable()); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_ndarray = ((PyTypeObject*)__pyx_t_1); __pyx_t_1 = 0; __pyx_v_itemsize = -1L; if (unlikely(__pyx_v_args == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(0, 6, __pyx_L1_error) } __pyx_t_5 = PyTuple_GET_SIZE(((PyObject*)__pyx_v_args)); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 6, __pyx_L1_error) __pyx_t_2 = ((0 < __pyx_t_5) != 0); if (__pyx_t_2) { if (unlikely(__pyx_v_args == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 6, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(((PyObject*)__pyx_v_args), 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_arg = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L6; } __pyx_t_3 = (__pyx_v_kwargs != Py_None); __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { } else { __pyx_t_2 = __pyx_t_4; goto __pyx_L7_bool_binop_done; } if (unlikely(__pyx_v_kwargs == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); __PYX_ERR(0, 6, __pyx_L1_error) } __pyx_t_4 = (__Pyx_PyDict_ContainsTF(__pyx_n_s_value, ((PyObject*)__pyx_v_kwargs), Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 6, __pyx_L1_error) __pyx_t_3 = (__pyx_t_4 != 0); __pyx_t_2 = __pyx_t_3; __pyx_L7_bool_binop_done:; if (__pyx_t_2) { if (unlikely(__pyx_v_kwargs == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 6, __pyx_L1_error) } __pyx_t_1 = __Pyx_PyDict_GetItem(((PyObject*)__pyx_v_kwargs), __pyx_n_s_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_arg = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L6; } /*else*/ { if (unlikely(__pyx_v_args == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(0, 6, __pyx_L1_error) } __pyx_t_5 = PyTuple_GET_SIZE(((PyObject*)__pyx_v_args)); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 6, __pyx_L1_error) __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_int_1); __Pyx_GIVEREF(__pyx_int_1); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_int_1); __Pyx_INCREF(__pyx_kp_s_); __Pyx_GIVEREF(__pyx_kp_s_); PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_kp_s_); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Expected_at_least_d_argument_s_g, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 6, __pyx_L1_error) } __pyx_L6:; while (1) { __pyx_t_2 = PyFloat_Check(__pyx_v_arg); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, __pyx_n_s_double, long, 1, __Pyx_PyInt_From_long, 1, 0, 1) < 0)) __PYX_ERR(0, 6, __pyx_L1_error) goto __pyx_L10_break; } if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, Py_None, long, 1, __Pyx_PyInt_From_long, 1, 0, 1) < 0)) __PYX_ERR(0, 6, __pyx_L1_error) goto __pyx_L10_break; } __pyx_L10_break:; __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_candidates = ((PyObject*)__pyx_t_6); __pyx_t_6 = 0; __pyx_t_5 = 0; if (unlikely(__pyx_v_signatures == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); __PYX_ERR(0, 6, __pyx_L1_error) } __pyx_t_1 = __Pyx_dict_iterator(((PyObject*)__pyx_v_signatures), 1, ((PyObject *)NULL), (&__pyx_t_7), (&__pyx_t_8)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = __pyx_t_1; __pyx_t_1 = 0; while (1) { __pyx_t_9 = __Pyx_dict_iter_next(__pyx_t_6, __pyx_t_7, &__pyx_t_5, &__pyx_t_1, NULL, NULL, __pyx_t_8); if (unlikely(__pyx_t_9 == 0)) break; if (unlikely(__pyx_t_9 == -1)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_sig, __pyx_t_1); __pyx_t_1 = 0; __pyx_v_match_found = 0; __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_sig, __pyx_n_s_strip); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_split); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF_SET(__pyx_v_src_sig, __pyx_t_10); __pyx_t_10 = 0; __pyx_t_11 = PyList_GET_SIZE(__pyx_v_dest_sig); if (unlikely(__pyx_t_11 == ((Py_ssize_t)-1))) __PYX_ERR(0, 6, __pyx_L1_error) __pyx_t_12 = __pyx_t_11; for (__pyx_t_13 = 0; __pyx_t_13 < __pyx_t_12; __pyx_t_13+=1) { __pyx_v_i = __pyx_t_13; __pyx_t_10 = __Pyx_GetItemInt_List(__pyx_v_dest_sig, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_XDECREF_SET(__pyx_v_dst_type, __pyx_t_10); __pyx_t_10 = 0; __pyx_t_3 = (__pyx_v_dst_type != Py_None); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_src_sig, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __pyx_t_1 = PyObject_RichCompare(__pyx_t_10, __pyx_v_dst_type, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_2) { __pyx_v_match_found = 1; goto __pyx_L17; } /*else*/ { __pyx_v_match_found = 0; goto __pyx_L15_break; } __pyx_L17:; } } __pyx_L15_break:; __pyx_t_2 = (__pyx_v_match_found != 0); if (__pyx_t_2) { __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_candidates, __pyx_v_sig); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(0, 6, __pyx_L1_error) } } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = (PyList_GET_SIZE(__pyx_v_candidates) != 0); __pyx_t_3 = ((!__pyx_t_2) != 0); if (__pyx_t_3) { __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 6, __pyx_L1_error) } __pyx_t_7 = PyList_GET_SIZE(__pyx_v_candidates); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(0, 6, __pyx_L1_error) __pyx_t_3 = ((__pyx_t_7 > 1) != 0); if (__pyx_t_3) { __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 6, __pyx_L1_error) } /*else*/ { __Pyx_XDECREF(__pyx_r); if (unlikely(__pyx_v_signatures == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 6, __pyx_L1_error) } __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_v_candidates, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_1 = __Pyx_PyDict_GetItem(((PyObject*)__pyx_v_signatures), __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; } /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("cython_test.__pyx_fused_cpdef", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_dest_sig); __Pyx_XDECREF(__pyx_v_ndarray); __Pyx_XDECREF(__pyx_v_arg); __Pyx_XDECREF(__pyx_v_candidates); __Pyx_XDECREF(__pyx_v_sig); __Pyx_XDECREF(__pyx_v_src_sig); __Pyx_XDECREF(__pyx_v_dst_type); __Pyx_XDECREF(__pyx_v_kwargs); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pw_11cython_test_3__pyx_fuse_0sqrt(PyObject *__pyx_self, PyObject *__pyx_arg_value); /*proto*/ static PyObject *__pyx_pw_11cython_test_1sqrt(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyObject *__pyx_fuse_0__pyx_f_11cython_test_sqrt(float __pyx_v_value, CYTHON_UNUSED int __pyx_skip_dispatch) { double __pyx_v_x; CYTHON_UNUSED long __pyx_v__; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations long __pyx_t_1; double __pyx_t_2; double __pyx_t_3; PyObject *__pyx_t_4 = NULL; __Pyx_RefNannySetupContext("__pyx_fuse_0sqrt", 0); /* "cython_test.pyx":9 * # solve for the square root of value by finding the zeros of * # 'x * x - value = 0' using newtons meethod * cdef double x = value / 2 # <<<<<<<<<<<<<< * for _ in range(8): * x -= (x * x - value) / (2 * x) */ __pyx_v_x = (__pyx_v_value / 2.0); /* "cython_test.pyx":10 * # 'x * x - value = 0' using newtons meethod * cdef double x = value / 2 * for _ in range(8): # <<<<<<<<<<<<<< * x -= (x * x - value) / (2 * x) * return x */ for (__pyx_t_1 = 0; __pyx_t_1 < 8; __pyx_t_1+=1) { __pyx_v__ = __pyx_t_1; /* "cython_test.pyx":11 * cdef double x = value / 2 * for _ in range(8): * x -= (x * x - value) / (2 * x) # <<<<<<<<<<<<<< * return x */ __pyx_t_2 = ((__pyx_v_x * __pyx_v_x) - __pyx_v_value); __pyx_t_3 = (2.0 * __pyx_v_x); if (unlikely(__pyx_t_3 == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 11, __pyx_L1_error) } __pyx_v_x = (__pyx_v_x - (__pyx_t_2 / __pyx_t_3)); } /* "cython_test.pyx":12 * for _ in range(8): * x -= (x * x - value) / (2 * x) * return x # <<<<<<<<<<<<<< */ __Pyx_XDECREF(__pyx_r); __pyx_t_4 = PyFloat_FromDouble(__pyx_v_x); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; /* "cython_test.pyx":6 * from cython cimport floating * * cpdef sqrt(floating value): # <<<<<<<<<<<<<< * # solve for the square root of value by finding the zeros of * # 'x * x - value = 0' using newtons meethod */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("cython_test.sqrt", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_pw_11cython_test_3__pyx_fuse_0sqrt(PyObject *__pyx_self, PyObject *__pyx_arg_value); /*proto*/ static PyMethodDef __pyx_fuse_0__pyx_mdef_11cython_test_3__pyx_fuse_0sqrt = {"__pyx_fuse_0sqrt", (PyCFunction)__pyx_pw_11cython_test_3__pyx_fuse_0sqrt, METH_O, 0}; static PyObject *__pyx_pw_11cython_test_3__pyx_fuse_0sqrt(PyObject *__pyx_self, PyObject *__pyx_arg_value) { float __pyx_v_value; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__pyx_fuse_0sqrt (wrapper)", 0); assert(__pyx_arg_value); { __pyx_v_value = __pyx_PyFloat_AsFloat(__pyx_arg_value); if (unlikely((__pyx_v_value == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 6, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; __Pyx_AddTraceback("cython_test.__pyx_fuse_0sqrt", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_11cython_test_2__pyx_fuse_0sqrt(__pyx_self, ((float)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_11cython_test_2__pyx_fuse_0sqrt(CYTHON_UNUSED PyObject *__pyx_self, float __pyx_v_value) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("__pyx_fuse_0sqrt", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_fuse_0__pyx_f_11cython_test_sqrt(__pyx_v_value, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("cython_test.__pyx_fuse_0sqrt", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pw_11cython_test_5__pyx_fuse_1sqrt(PyObject *__pyx_self, PyObject *__pyx_arg_value); /*proto*/ static PyObject *__pyx_pw_11cython_test_1sqrt(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyObject *__pyx_fuse_1__pyx_f_11cython_test_sqrt(double __pyx_v_value, CYTHON_UNUSED int __pyx_skip_dispatch) { double __pyx_v_x; CYTHON_UNUSED long __pyx_v__; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations long __pyx_t_1; double __pyx_t_2; double __pyx_t_3; PyObject *__pyx_t_4 = NULL; __Pyx_RefNannySetupContext("__pyx_fuse_1sqrt", 0); /* "cython_test.pyx":9 * # solve for the square root of value by finding the zeros of * # 'x * x - value = 0' using newtons meethod * cdef double x = value / 2 # <<<<<<<<<<<<<< * for _ in range(8): * x -= (x * x - value) / (2 * x) */ __pyx_v_x = (__pyx_v_value / 2.0); /* "cython_test.pyx":10 * # 'x * x - value = 0' using newtons meethod * cdef double x = value / 2 * for _ in range(8): # <<<<<<<<<<<<<< * x -= (x * x - value) / (2 * x) * return x */ for (__pyx_t_1 = 0; __pyx_t_1 < 8; __pyx_t_1+=1) { __pyx_v__ = __pyx_t_1; /* "cython_test.pyx":11 * cdef double x = value / 2 * for _ in range(8): * x -= (x * x - value) / (2 * x) # <<<<<<<<<<<<<< * return x */ __pyx_t_2 = ((__pyx_v_x * __pyx_v_x) - __pyx_v_value); __pyx_t_3 = (2.0 * __pyx_v_x); if (unlikely(__pyx_t_3 == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 11, __pyx_L1_error) } __pyx_v_x = (__pyx_v_x - (__pyx_t_2 / __pyx_t_3)); } /* "cython_test.pyx":12 * for _ in range(8): * x -= (x * x - value) / (2 * x) * return x # <<<<<<<<<<<<<< */ __Pyx_XDECREF(__pyx_r); __pyx_t_4 = PyFloat_FromDouble(__pyx_v_x); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; /* "cython_test.pyx":6 * from cython cimport floating * * cpdef sqrt(floating value): # <<<<<<<<<<<<<< * # solve for the square root of value by finding the zeros of * # 'x * x - value = 0' using newtons meethod */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("cython_test.sqrt", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_pw_11cython_test_5__pyx_fuse_1sqrt(PyObject *__pyx_self, PyObject *__pyx_arg_value); /*proto*/ static PyMethodDef __pyx_fuse_1__pyx_mdef_11cython_test_5__pyx_fuse_1sqrt = {"__pyx_fuse_1sqrt", (PyCFunction)__pyx_pw_11cython_test_5__pyx_fuse_1sqrt, METH_O, 0}; static PyObject *__pyx_pw_11cython_test_5__pyx_fuse_1sqrt(PyObject *__pyx_self, PyObject *__pyx_arg_value) { double __pyx_v_value; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__pyx_fuse_1sqrt (wrapper)", 0); assert(__pyx_arg_value); { __pyx_v_value = __pyx_PyFloat_AsDouble(__pyx_arg_value); if (unlikely((__pyx_v_value == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 6, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; __Pyx_AddTraceback("cython_test.__pyx_fuse_1sqrt", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_11cython_test_4__pyx_fuse_1sqrt(__pyx_self, ((double)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_11cython_test_4__pyx_fuse_1sqrt(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_value) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("__pyx_fuse_1sqrt", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_fuse_1__pyx_f_11cython_test_sqrt(__pyx_v_value, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("cython_test.__pyx_fuse_1sqrt", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; #if PY_MAJOR_VERSION >= 3 #if CYTHON_PEP489_MULTI_PHASE_INIT static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ static int __pyx_pymod_exec_cython_test(PyObject* module); /*proto*/ static PyModuleDef_Slot __pyx_moduledef_slots[] = { {Py_mod_create, (void*)__pyx_pymod_create}, {Py_mod_exec, (void*)__pyx_pymod_exec_cython_test}, {0, NULL} }; #endif static struct PyModuleDef __pyx_moduledef = { PyModuleDef_HEAD_INIT, "cython_test", __pyx_k_simple_test_file_for_cython_sou, /* m_doc */ #if CYTHON_PEP489_MULTI_PHASE_INIT 0, /* m_size */ #else -1, /* m_size */ #endif __pyx_methods /* m_methods */, #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_moduledef_slots, /* m_slots */ #else NULL, /* m_reload */ #endif NULL, /* m_traverse */ NULL, /* m_clear */ NULL /* m_free */ }; #endif static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_kp_s_, __pyx_k_, sizeof(__pyx_k_), 0, 0, 1, 0}, {&__pyx_kp_s_Expected_at_least_d_argument_s_g, __pyx_k_Expected_at_least_d_argument_s_g, sizeof(__pyx_k_Expected_at_least_d_argument_s_g), 0, 0, 1, 0}, {&__pyx_kp_s_Function_call_with_ambiguous_arg, __pyx_k_Function_call_with_ambiguous_arg, sizeof(__pyx_k_Function_call_with_ambiguous_arg), 0, 0, 1, 0}, {&__pyx_kp_s_No_matching_signature_found, __pyx_k_No_matching_signature_found, sizeof(__pyx_k_No_matching_signature_found), 0, 0, 1, 0}, {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, {&__pyx_kp_s__2, __pyx_k__2, sizeof(__pyx_k__2), 0, 0, 1, 0}, {&__pyx_kp_s__4, __pyx_k__4, sizeof(__pyx_k__4), 0, 0, 1, 0}, {&__pyx_n_s_args, __pyx_k_args, sizeof(__pyx_k_args), 0, 0, 1, 1}, {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, {&__pyx_n_s_cython_test, __pyx_k_cython_test, sizeof(__pyx_k_cython_test), 0, 0, 1, 1}, {&__pyx_kp_s_cython_test_pyx, __pyx_k_cython_test_pyx, sizeof(__pyx_k_cython_test_pyx), 0, 0, 1, 0}, {&__pyx_n_s_defaults, __pyx_k_defaults, sizeof(__pyx_k_defaults), 0, 0, 1, 1}, {&__pyx_n_s_double, __pyx_k_double, sizeof(__pyx_k_double), 0, 0, 1, 1}, {&__pyx_n_s_float, __pyx_k_float, sizeof(__pyx_k_float), 0, 0, 1, 1}, {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, {&__pyx_n_s_kwargs, __pyx_k_kwargs, sizeof(__pyx_k_kwargs), 0, 0, 1, 1}, {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, {&__pyx_n_s_pyx_fuse_0sqrt, __pyx_k_pyx_fuse_0sqrt, sizeof(__pyx_k_pyx_fuse_0sqrt), 0, 0, 1, 1}, {&__pyx_n_s_pyx_fuse_1sqrt, __pyx_k_pyx_fuse_1sqrt, sizeof(__pyx_k_pyx_fuse_1sqrt), 0, 0, 1, 1}, {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, {&__pyx_n_s_signatures, __pyx_k_signatures, sizeof(__pyx_k_signatures), 0, 0, 1, 1}, {&__pyx_n_s_split, __pyx_k_split, sizeof(__pyx_k_split), 0, 0, 1, 1}, {&__pyx_n_s_sqrt, __pyx_k_sqrt, sizeof(__pyx_k_sqrt), 0, 0, 1, 1}, {&__pyx_n_s_strip, __pyx_k_strip, sizeof(__pyx_k_strip), 0, 0, 1, 1}, {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, {&__pyx_n_s_value, __pyx_k_value, sizeof(__pyx_k_value), 0, 0, 1, 1}, {0, 0, 0, 0, 0, 0, 0} }; static int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 6, __pyx_L1_error) __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 6, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } static int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); /* "cython_test.pyx":6 * from cython cimport floating * * cpdef sqrt(floating value): # <<<<<<<<<<<<<< * # solve for the square root of value by finding the zeros of * # 'x * x - value = 0' using newtons meethod */ __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_s__2); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__3); __Pyx_GIVEREF(__pyx_tuple__3); __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_s__4); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__5); __Pyx_GIVEREF(__pyx_tuple__5); __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_s_No_matching_signature_found); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__6); __Pyx_GIVEREF(__pyx_tuple__6); __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_s_Function_call_with_ambiguous_arg); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__7); __Pyx_GIVEREF(__pyx_tuple__7); __pyx_tuple__8 = PyTuple_Pack(2, __pyx_n_s_value, __pyx_n_s_value); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__8); __Pyx_GIVEREF(__pyx_tuple__8); __pyx_codeobj__9 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__8, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_cython_test_pyx, __pyx_n_s_pyx_fuse_0sqrt, 6, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__9)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_InitGlobals(void) { if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } static int __Pyx_modinit_global_init_code(void); /*proto*/ static int __Pyx_modinit_variable_export_code(void); /*proto*/ static int __Pyx_modinit_function_export_code(void); /*proto*/ static int __Pyx_modinit_type_init_code(void); /*proto*/ static int __Pyx_modinit_type_import_code(void); /*proto*/ static int __Pyx_modinit_variable_import_code(void); /*proto*/ static int __Pyx_modinit_function_import_code(void); /*proto*/ static int __Pyx_modinit_global_init_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); /*--- Global init code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_variable_export_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); /*--- Variable export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_export_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); /*--- Function export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_type_init_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); /*--- Type init code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_type_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); /*--- Type import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_variable_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); /*--- Variable import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); /*--- Function import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } #if PY_MAJOR_VERSION < 3 #ifdef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC void #else #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #endif #else #ifdef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC PyObject * #else #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #endif #endif #ifndef CYTHON_SMALL_CODE #if defined(__clang__) #define CYTHON_SMALL_CODE #elif defined(__GNUC__) && (!(defined(__cplusplus)) || (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 4))) #define CYTHON_SMALL_CODE __attribute__((cold)) #else #define CYTHON_SMALL_CODE #endif #endif #if PY_MAJOR_VERSION < 3 __Pyx_PyMODINIT_FUNC initcython_test(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC initcython_test(void) #else __Pyx_PyMODINIT_FUNC PyInit_cython_test(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC PyInit_cython_test(void) #if CYTHON_PEP489_MULTI_PHASE_INIT { return PyModuleDef_Init(&__pyx_moduledef); } static int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name) { PyObject *value = PyObject_GetAttrString(spec, from_name); int result = 0; if (likely(value)) { result = PyDict_SetItemString(moddict, to_name, value); Py_DECREF(value); } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Clear(); } else { result = -1; } return result; } static PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { PyObject *module = NULL, *moddict, *modname; if (__pyx_m) return __Pyx_NewRef(__pyx_m); modname = PyObject_GetAttrString(spec, "name"); if (unlikely(!modname)) goto bad; module = PyModule_NewObject(modname); Py_DECREF(modname); if (unlikely(!module)) goto bad; moddict = PyModule_GetDict(module); if (unlikely(!moddict)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__") < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__") < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__") < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__") < 0)) goto bad; return module; bad: Py_XDECREF(module); return NULL; } static int __pyx_pymod_exec_cython_test(PyObject *__pyx_pyinit_module) #endif #endif { PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; __Pyx_RefNannyDeclarations #if CYTHON_PEP489_MULTI_PHASE_INIT if (__pyx_m && __pyx_m == __pyx_pyinit_module) return 0; #elif PY_MAJOR_VERSION >= 3 if (__pyx_m) return __Pyx_NewRef(__pyx_m); #endif #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { PyErr_Clear(); __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); if (!__Pyx_RefNanny) Py_FatalError("failed to import 'refnanny' module"); } #endif __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_cython_test(void)", 0); if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pyx_CyFunction_USED if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_FusedFunction_USED if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Coroutine_USED if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Generator_USED if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_AsyncGen_USED if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_StopAsyncIteration_USED if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS #ifdef WITH_THREAD /* Python build with threading support? */ PyEval_InitThreads(); #endif #endif /*--- Module creation code ---*/ #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_m = __pyx_pyinit_module; Py_INCREF(__pyx_m); #else #if PY_MAJOR_VERSION < 3 __pyx_m = Py_InitModule4("cython_test", __pyx_methods, __pyx_k_simple_test_file_for_cython_sou, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); #else __pyx_m = PyModule_Create(&__pyx_moduledef); #endif if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) #endif __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) Py_INCREF(__pyx_d); __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) #if CYTHON_COMPILING_IN_PYPY Py_INCREF(__pyx_b); #endif if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); /*--- Initialize various global constants etc. ---*/ if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif if (__pyx_module_is_main_cython_test) { if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) } #if PY_MAJOR_VERSION >= 3 { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) if (!PyDict_GetItemString(modules, "cython_test")) { if (unlikely(PyDict_SetItemString(modules, "cython_test", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) } } #endif /*--- Builtin init code ---*/ if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Constants init code ---*/ if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Global type/function init code ---*/ (void)__Pyx_modinit_global_init_code(); (void)__Pyx_modinit_variable_export_code(); (void)__Pyx_modinit_function_export_code(); (void)__Pyx_modinit_type_init_code(); (void)__Pyx_modinit_type_import_code(); (void)__Pyx_modinit_variable_import_code(); (void)__Pyx_modinit_function_import_code(); /*--- Execution code ---*/ #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /* "cython_test.pyx":6 * from cython cimport floating * * cpdef sqrt(floating value): # <<<<<<<<<<<<<< * # solve for the square root of value by finding the zeros of * # 'x * x - value = 0' using newtons meethod */ __pyx_t_1 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __pyx_FusedFunction_NewEx(&__pyx_fuse_0__pyx_mdef_11cython_test_3__pyx_fuse_0sqrt, 0, __pyx_n_s_pyx_fuse_0sqrt, NULL, __pyx_n_s_cython_test, __pyx_d, ((PyObject *)__pyx_codeobj__9)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_empty_tuple); if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_float, __pyx_t_2) < 0) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __pyx_FusedFunction_NewEx(&__pyx_fuse_1__pyx_mdef_11cython_test_5__pyx_fuse_1sqrt, 0, __pyx_n_s_pyx_fuse_1sqrt, NULL, __pyx_n_s_cython_test, __pyx_d, ((PyObject *)__pyx_codeobj__9)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_empty_tuple); if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_double, __pyx_t_2) < 0) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __pyx_FusedFunction_NewEx(&__pyx_mdef_11cython_test_1sqrt, 0, __pyx_n_s_sqrt, NULL, __pyx_n_s_cython_test, __pyx_d, ((PyObject *)__pyx_codeobj__9)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_empty_tuple); ((__pyx_FusedFunctionObject *) __pyx_t_2)->__signatures__ = __pyx_t_1; __Pyx_GIVEREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_sqrt, __pyx_t_2) < 0) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "cython_test.pyx":1 * """ simple test file for cython source mapping: defines a function # <<<<<<<<<<<<<< * that uses newtowns method to compute the square root of a number """ * */ __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_3) < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /*--- Wrapped vars code ---*/ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); if (__pyx_m) { if (__pyx_d) { __Pyx_AddTraceback("init cython_test", 0, __pyx_lineno, __pyx_filename); } Py_DECREF(__pyx_m); __pyx_m = 0; } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init cython_test"); } __pyx_L0:; __Pyx_RefNannyFinishContext(); #if CYTHON_PEP489_MULTI_PHASE_INIT return (__pyx_m != NULL) ? 0 : -1; #elif PY_MAJOR_VERSION >= 3 return __pyx_m; #else return; #endif } /* --- Runtime support code --- */ /* Refnanny */ #if CYTHON_REFNANNY static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { PyObject *m = NULL, *p = NULL; void *r = NULL; m = PyImport_ImportModule((char *)modname); if (!m) goto end; p = PyObject_GetAttrString(m, (char *)"RefNannyAPI"); if (!p) goto end; r = PyLong_AsVoidPtr(p); end: Py_XDECREF(p); Py_XDECREF(m); return (__Pyx_RefNannyAPIStruct *)r; } #endif /* PyObjectGetAttrStr */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_getattro)) return tp->tp_getattro(obj, attr_name); #if PY_MAJOR_VERSION < 3 if (likely(tp->tp_getattr)) return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); #endif return PyObject_GetAttr(obj, attr_name); } #endif /* GetBuiltinName */ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); if (unlikely(!result)) { PyErr_Format(PyExc_NameError, #if PY_MAJOR_VERSION >= 3 "name '%U' is not defined", name); #else "name '%.200s' is not defined", PyString_AS_STRING(name)); #endif } return result; } /* RaiseArgTupleInvalid */ static void __Pyx_RaiseArgtupleInvalid( const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found) { Py_ssize_t num_expected; const char *more_or_less; if (num_found < num_min) { num_expected = num_min; more_or_less = "at least"; } else { num_expected = num_max; more_or_less = "at most"; } if (exact) { more_or_less = "exactly"; } PyErr_Format(PyExc_TypeError, "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", func_name, more_or_less, num_expected, (num_expected == 1) ? "" : "s", num_found); } /* RaiseDoubleKeywords */ static void __Pyx_RaiseDoubleKeywordsError( const char* func_name, PyObject* kw_name) { PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION >= 3 "%s() got multiple values for keyword argument '%U'", func_name, kw_name); #else "%s() got multiple values for keyword argument '%s'", func_name, PyString_AsString(kw_name)); #endif } /* ParseKeywords */ static int __Pyx_ParseOptionalKeywords( PyObject *kwds, PyObject **argnames[], PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, const char* function_name) { PyObject *key = 0, *value = 0; Py_ssize_t pos = 0; PyObject*** name; PyObject*** first_kw_arg = argnames + num_pos_args; while (PyDict_Next(kwds, &pos, &key, &value)) { name = first_kw_arg; while (*name && (**name != key)) name++; if (*name) { values[name-argnames] = value; continue; } name = first_kw_arg; #if PY_MAJOR_VERSION < 3 if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) { while (*name) { if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) && _PyString_Eq(**name, key)) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { if ((**argname == key) || ( (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) && _PyString_Eq(**argname, key))) { goto arg_passed_twice; } argname++; } } } else #endif if (likely(PyUnicode_Check(key))) { while (*name) { int cmp = (**name == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 : #endif PyUnicode_Compare(**name, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { int cmp = (**argname == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 : #endif PyUnicode_Compare(**argname, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) goto arg_passed_twice; argname++; } } } else goto invalid_keyword_type; if (kwds2) { if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; } else { goto invalid_keyword; } } return 0; arg_passed_twice: __Pyx_RaiseDoubleKeywordsError(function_name, key); goto bad; invalid_keyword_type: PyErr_Format(PyExc_TypeError, "%.200s() keywords must be strings", function_name); goto bad; invalid_keyword: PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION < 3 "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else "%s() got an unexpected keyword argument '%U'", function_name, key); #endif bad: return -1; } /* GetItemInt */ static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { PyObject *r; if (!j) return NULL; r = PyObject_GetItem(o, j); Py_DECREF(j); return r; } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS Py_ssize_t wrapped_i = i; if (wraparound & unlikely(i < 0)) { wrapped_i += PyList_GET_SIZE(o); } if ((!boundscheck) || likely((0 <= wrapped_i) & (wrapped_i < PyList_GET_SIZE(o)))) { PyObject *r = PyList_GET_ITEM(o, wrapped_i); Py_INCREF(r); return r; } return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); #else return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS Py_ssize_t wrapped_i = i; if (wraparound & unlikely(i < 0)) { wrapped_i += PyTuple_GET_SIZE(o); } if ((!boundscheck) || likely((0 <= wrapped_i) & (wrapped_i < PyTuple_GET_SIZE(o)))) { PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); Py_INCREF(r); return r; } return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); #else return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS if (is_list || PyList_CheckExact(o)) { Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); if ((!boundscheck) || (likely((n >= 0) & (n < PyList_GET_SIZE(o))))) { PyObject *r = PyList_GET_ITEM(o, n); Py_INCREF(r); return r; } } else if (PyTuple_CheckExact(o)) { Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); if ((!boundscheck) || likely((n >= 0) & (n < PyTuple_GET_SIZE(o)))) { PyObject *r = PyTuple_GET_ITEM(o, n); Py_INCREF(r); return r; } } else { PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; if (likely(m && m->sq_item)) { if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { Py_ssize_t l = m->sq_length(o); if (likely(l >= 0)) { i += l; } else { if (!PyErr_ExceptionMatches(PyExc_OverflowError)) return NULL; PyErr_Clear(); } } return m->sq_item(o, i); } } #else if (is_list || PySequence_Check(o)) { return PySequence_GetItem(o, i); } #endif return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); } /* DictGetItem */ #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { PyObject *value; value = PyDict_GetItemWithError(d, key); if (unlikely(!value)) { if (!PyErr_Occurred()) { PyObject* args = PyTuple_Pack(1, key); if (likely(args)) PyErr_SetObject(PyExc_KeyError, args); Py_XDECREF(args); } return NULL; } Py_INCREF(value); return value; } #endif /* PyCFunctionFastCall */ #if CYTHON_FAST_PYCCALL static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { PyCFunctionObject *func = (PyCFunctionObject*)func_obj; PyCFunction meth = PyCFunction_GET_FUNCTION(func); PyObject *self = PyCFunction_GET_SELF(func); int flags = PyCFunction_GET_FLAGS(func); assert(PyCFunction_Check(func)); assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS))); assert(nargs >= 0); assert(nargs == 0 || args != NULL); /* _PyCFunction_FastCallDict() must not be called with an exception set, because it may clear it (directly or indirectly) and so the caller loses its exception */ assert(!PyErr_Occurred()); if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { return (*((__Pyx_PyCFunctionFastWithKeywords)meth)) (self, args, nargs, NULL); } else { return (*((__Pyx_PyCFunctionFast)meth)) (self, args, nargs); } } #endif /* PyFunctionFastCall */ #if CYTHON_FAST_PYCALL #include "frameobject.h" static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, PyObject *globals) { PyFrameObject *f; PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject **fastlocals; Py_ssize_t i; PyObject *result; assert(globals != NULL); /* XXX Perhaps we should create a specialized PyFrame_New() that doesn't take locals, but does take builtins without sanity checking them. */ assert(tstate != NULL); f = PyFrame_New(tstate, co, globals, NULL); if (f == NULL) { return NULL; } fastlocals = f->f_localsplus; for (i = 0; i < na; i++) { Py_INCREF(*args); fastlocals[i] = *args++; } result = PyEval_EvalFrameEx(f,0); ++tstate->recursion_depth; Py_DECREF(f); --tstate->recursion_depth; return result; } #if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs) { PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); PyObject *globals = PyFunction_GET_GLOBALS(func); PyObject *argdefs = PyFunction_GET_DEFAULTS(func); PyObject *closure; #if PY_MAJOR_VERSION >= 3 PyObject *kwdefs; #endif PyObject *kwtuple, **k; PyObject **d; Py_ssize_t nd; Py_ssize_t nk; PyObject *result; assert(kwargs == NULL || PyDict_Check(kwargs)); nk = kwargs ? PyDict_Size(kwargs) : 0; if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { return NULL; } if ( #if PY_MAJOR_VERSION >= 3 co->co_kwonlyargcount == 0 && #endif likely(kwargs == NULL || nk == 0) && co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { if (argdefs == NULL && co->co_argcount == nargs) { result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); goto done; } else if (nargs == 0 && argdefs != NULL && co->co_argcount == Py_SIZE(argdefs)) { /* function called with no arguments, but all parameters have a default value: use default values as arguments .*/ args = &PyTuple_GET_ITEM(argdefs, 0); result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); goto done; } } if (kwargs != NULL) { Py_ssize_t pos, i; kwtuple = PyTuple_New(2 * nk); if (kwtuple == NULL) { result = NULL; goto done; } k = &PyTuple_GET_ITEM(kwtuple, 0); pos = i = 0; while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { Py_INCREF(k[i]); Py_INCREF(k[i+1]); i += 2; } nk = i / 2; } else { kwtuple = NULL; k = NULL; } closure = PyFunction_GET_CLOSURE(func); #if PY_MAJOR_VERSION >= 3 kwdefs = PyFunction_GET_KW_DEFAULTS(func); #endif if (argdefs != NULL) { d = &PyTuple_GET_ITEM(argdefs, 0); nd = Py_SIZE(argdefs); } else { d = NULL; nd = 0; } #if PY_MAJOR_VERSION >= 3 result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, args, nargs, k, (int)nk, d, (int)nd, kwdefs, closure); #else result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, args, nargs, k, (int)nk, d, (int)nd, closure); #endif Py_XDECREF(kwtuple); done: Py_LeaveRecursiveCall(); return result; } #endif #endif /* PyObjectCall */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { PyObject *result; ternaryfunc call = func->ob_type->tp_call; if (unlikely(!call)) return PyObject_Call(func, arg, kw); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = (*call)(func, arg, kw); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* PyObjectCallMethO */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { PyObject *self, *result; PyCFunction cfunc; cfunc = PyCFunction_GET_FUNCTION(func); self = PyCFunction_GET_SELF(func); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = cfunc(self, arg); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* PyObjectCallOneArg */ #if CYTHON_COMPILING_IN_CPYTHON static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_New(1); if (unlikely(!args)) return NULL; Py_INCREF(arg); PyTuple_SET_ITEM(args, 0, arg); result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { #if CYTHON_FAST_PYCALL if (PyFunction_Check(func)) { return __Pyx_PyFunction_FastCall(func, &arg, 1); } #endif if (likely(PyCFunction_Check(func))) { if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { return __Pyx_PyObject_CallMethO(func, arg); #if CYTHON_FAST_PYCCALL } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) { return __Pyx_PyCFunction_FastCall(func, &arg, 1); #endif } } return __Pyx__PyObject_CallOneArg(func, arg); } #else static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_Pack(1, arg); if (unlikely(!args)) return NULL; result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } #endif /* PyErrFetchRestore */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; tmp_type = tstate->curexc_type; tmp_value = tstate->curexc_value; tmp_tb = tstate->curexc_traceback; tstate->curexc_type = type; tstate->curexc_value = value; tstate->curexc_traceback = tb; Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); } static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { *type = tstate->curexc_type; *value = tstate->curexc_value; *tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; } #endif /* RaiseException */ #if PY_MAJOR_VERSION < 3 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, CYTHON_UNUSED PyObject *cause) { __Pyx_PyThreadState_declare Py_XINCREF(type); if (!value || value == Py_None) value = NULL; else Py_INCREF(value); if (!tb || tb == Py_None) tb = NULL; else { Py_INCREF(tb); if (!PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto raise_error; } } if (PyType_Check(type)) { #if CYTHON_COMPILING_IN_PYPY if (!value) { Py_INCREF(Py_None); value = Py_None; } #endif PyErr_NormalizeException(&type, &value, &tb); } else { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto raise_error; } value = type; type = (PyObject*) Py_TYPE(type); Py_INCREF(type); if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto raise_error; } } __Pyx_PyThreadState_assign __Pyx_ErrRestore(type, value, tb); return; raise_error: Py_XDECREF(value); Py_XDECREF(type); Py_XDECREF(tb); return; } #else static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { PyObject* owned_instance = NULL; if (tb == Py_None) { tb = 0; } else if (tb && !PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto bad; } if (value == Py_None) value = 0; if (PyExceptionInstance_Check(type)) { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto bad; } value = type; type = (PyObject*) Py_TYPE(value); } else if (PyExceptionClass_Check(type)) { PyObject *instance_class = NULL; if (value && PyExceptionInstance_Check(value)) { instance_class = (PyObject*) Py_TYPE(value); if (instance_class != type) { int is_subclass = PyObject_IsSubclass(instance_class, type); if (!is_subclass) { instance_class = NULL; } else if (unlikely(is_subclass == -1)) { goto bad; } else { type = instance_class; } } } if (!instance_class) { PyObject *args; if (!value) args = PyTuple_New(0); else if (PyTuple_Check(value)) { Py_INCREF(value); args = value; } else args = PyTuple_Pack(1, value); if (!args) goto bad; owned_instance = PyObject_Call(type, args, NULL); Py_DECREF(args); if (!owned_instance) goto bad; value = owned_instance; if (!PyExceptionInstance_Check(value)) { PyErr_Format(PyExc_TypeError, "calling %R should have returned an instance of " "BaseException, not %R", type, Py_TYPE(value)); goto bad; } } } else { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto bad; } if (cause) { PyObject *fixed_cause; if (cause == Py_None) { fixed_cause = NULL; } else if (PyExceptionClass_Check(cause)) { fixed_cause = PyObject_CallObject(cause, NULL); if (fixed_cause == NULL) goto bad; } else if (PyExceptionInstance_Check(cause)) { fixed_cause = cause; Py_INCREF(fixed_cause); } else { PyErr_SetString(PyExc_TypeError, "exception causes must derive from " "BaseException"); goto bad; } PyException_SetCause(value, fixed_cause); } PyErr_SetObject(type, value); if (tb) { #if CYTHON_COMPILING_IN_PYPY PyObject *tmp_type, *tmp_value, *tmp_tb; PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); Py_INCREF(tb); PyErr_Restore(tmp_type, tmp_value, tb); Py_XDECREF(tmp_tb); #else PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject* tmp_tb = tstate->curexc_traceback; if (tb != tmp_tb) { Py_INCREF(tb); tstate->curexc_traceback = tb; Py_XDECREF(tmp_tb); } #endif } bad: Py_XDECREF(owned_instance); return; } #endif /* SetItemInt */ static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) { int r; if (!j) return -1; r = PyObject_SetItem(o, j, v); Py_DECREF(j); return r; } static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, int is_list, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS if (is_list || PyList_CheckExact(o)) { Py_ssize_t n = (!wraparound) ? i : ((likely(i >= 0)) ? i : i + PyList_GET_SIZE(o)); if ((!boundscheck) || likely((n >= 0) & (n < PyList_GET_SIZE(o)))) { PyObject* old = PyList_GET_ITEM(o, n); Py_INCREF(v); PyList_SET_ITEM(o, n, v); Py_DECREF(old); return 1; } } else { PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; if (likely(m && m->sq_ass_item)) { if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { Py_ssize_t l = m->sq_length(o); if (likely(l >= 0)) { i += l; } else { if (!PyErr_ExceptionMatches(PyExc_OverflowError)) return -1; PyErr_Clear(); } } return m->sq_ass_item(o, i, v); } } #else #if CYTHON_COMPILING_IN_PYPY if (is_list || (PySequence_Check(o) && !PyDict_Check(o))) { #else if (is_list || PySequence_Check(o)) { #endif return PySequence_SetItem(o, i, v); } #endif return __Pyx_SetItemInt_Generic(o, PyInt_FromSsize_t(i), v); } /* IterFinish */ static CYTHON_INLINE int __Pyx_IterFinish(void) { #if CYTHON_FAST_THREAD_STATE PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject* exc_type = tstate->curexc_type; if (unlikely(exc_type)) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) { PyObject *exc_value, *exc_tb; exc_value = tstate->curexc_value; exc_tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; Py_DECREF(exc_type); Py_XDECREF(exc_value); Py_XDECREF(exc_tb); return 0; } else { return -1; } } return 0; #else if (unlikely(PyErr_Occurred())) { if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) { PyErr_Clear(); return 0; } else { return -1; } } return 0; #endif } /* PyObjectCallNoArg */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { #if CYTHON_FAST_PYCALL if (PyFunction_Check(func)) { return __Pyx_PyFunction_FastCall(func, NULL, 0); } #endif #ifdef __Pyx_CyFunction_USED if (likely(PyCFunction_Check(func) || __Pyx_TypeCheck(func, __pyx_CyFunctionType))) { #else if (likely(PyCFunction_Check(func))) { #endif if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { return __Pyx_PyObject_CallMethO(func, NULL); } } return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); } #endif /* PyObjectCallMethod0 */ static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { PyObject *method, *result = NULL; method = __Pyx_PyObject_GetAttrStr(obj, method_name); if (unlikely(!method)) goto bad; #if CYTHON_UNPACK_METHODS if (likely(PyMethod_Check(method))) { PyObject *self = PyMethod_GET_SELF(method); if (likely(self)) { PyObject *function = PyMethod_GET_FUNCTION(method); result = __Pyx_PyObject_CallOneArg(function, self); Py_DECREF(method); return result; } } #endif result = __Pyx_PyObject_CallNoArg(method); Py_DECREF(method); bad: return result; } /* RaiseNeedMoreValuesToUnpack */ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { PyErr_Format(PyExc_ValueError, "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", index, (index == 1) ? "" : "s"); } /* RaiseTooManyValuesToUnpack */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { PyErr_Format(PyExc_ValueError, "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); } /* UnpackItemEndCheck */ static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { if (unlikely(retval)) { Py_DECREF(retval); __Pyx_RaiseTooManyValuesError(expected); return -1; } else { return __Pyx_IterFinish(); } return 0; } /* RaiseNoneIterError */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); } /* UnpackTupleError */ static void __Pyx_UnpackTupleError(PyObject *t, Py_ssize_t index) { if (t == Py_None) { __Pyx_RaiseNoneNotIterableError(); } else if (PyTuple_GET_SIZE(t) < index) { __Pyx_RaiseNeedMoreValuesError(PyTuple_GET_SIZE(t)); } else { __Pyx_RaiseTooManyValuesError(index); } } /* UnpackTuple2 */ static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, int decref_tuple) { PyObject *value1 = NULL, *value2 = NULL; #if CYTHON_COMPILING_IN_PYPY value1 = PySequence_ITEM(tuple, 0); if (unlikely(!value1)) goto bad; value2 = PySequence_ITEM(tuple, 1); if (unlikely(!value2)) goto bad; #else value1 = PyTuple_GET_ITEM(tuple, 0); Py_INCREF(value1); value2 = PyTuple_GET_ITEM(tuple, 1); Py_INCREF(value2); #endif if (decref_tuple) { Py_DECREF(tuple); } *pvalue1 = value1; *pvalue2 = value2; return 0; #if CYTHON_COMPILING_IN_PYPY bad: Py_XDECREF(value1); Py_XDECREF(value2); if (decref_tuple) { Py_XDECREF(tuple); } return -1; #endif } static int __Pyx_unpack_tuple2_generic(PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, int has_known_size, int decref_tuple) { Py_ssize_t index; PyObject *value1 = NULL, *value2 = NULL, *iter = NULL; iternextfunc iternext; iter = PyObject_GetIter(tuple); if (unlikely(!iter)) goto bad; if (decref_tuple) { Py_DECREF(tuple); tuple = NULL; } iternext = Py_TYPE(iter)->tp_iternext; value1 = iternext(iter); if (unlikely(!value1)) { index = 0; goto unpacking_failed; } value2 = iternext(iter); if (unlikely(!value2)) { index = 1; goto unpacking_failed; } if (!has_known_size && unlikely(__Pyx_IternextUnpackEndCheck(iternext(iter), 2))) goto bad; Py_DECREF(iter); *pvalue1 = value1; *pvalue2 = value2; return 0; unpacking_failed: if (!has_known_size && __Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); bad: Py_XDECREF(iter); Py_XDECREF(value1); Py_XDECREF(value2); if (decref_tuple) { Py_XDECREF(tuple); } return -1; } /* dict_iter */ static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_dict, PyObject* method_name, Py_ssize_t* p_orig_length, int* p_source_is_dict) { is_dict = is_dict || likely(PyDict_CheckExact(iterable)); *p_source_is_dict = is_dict; if (is_dict) { #if !CYTHON_COMPILING_IN_PYPY *p_orig_length = PyDict_Size(iterable); Py_INCREF(iterable); return iterable; #elif PY_MAJOR_VERSION >= 3 static PyObject *py_items = NULL, *py_keys = NULL, *py_values = NULL; PyObject **pp = NULL; if (method_name) { const char *name = PyUnicode_AsUTF8(method_name); if (strcmp(name, "iteritems") == 0) pp = &py_items; else if (strcmp(name, "iterkeys") == 0) pp = &py_keys; else if (strcmp(name, "itervalues") == 0) pp = &py_values; if (pp) { if (!*pp) { *pp = PyUnicode_FromString(name + 4); if (!*pp) return NULL; } method_name = *pp; } } #endif } *p_orig_length = 0; if (method_name) { PyObject* iter; iterable = __Pyx_PyObject_CallMethod0(iterable, method_name); if (!iterable) return NULL; #if !CYTHON_COMPILING_IN_PYPY if (PyTuple_CheckExact(iterable) || PyList_CheckExact(iterable)) return iterable; #endif iter = PyObject_GetIter(iterable); Py_DECREF(iterable); return iter; } return PyObject_GetIter(iterable); } static CYTHON_INLINE int __Pyx_dict_iter_next( PyObject* iter_obj, CYTHON_NCP_UNUSED Py_ssize_t orig_length, CYTHON_NCP_UNUSED Py_ssize_t* ppos, PyObject** pkey, PyObject** pvalue, PyObject** pitem, int source_is_dict) { PyObject* next_item; #if !CYTHON_COMPILING_IN_PYPY if (source_is_dict) { PyObject *key, *value; if (unlikely(orig_length != PyDict_Size(iter_obj))) { PyErr_SetString(PyExc_RuntimeError, "dictionary changed size during iteration"); return -1; } if (unlikely(!PyDict_Next(iter_obj, ppos, &key, &value))) { return 0; } if (pitem) { PyObject* tuple = PyTuple_New(2); if (unlikely(!tuple)) { return -1; } Py_INCREF(key); Py_INCREF(value); PyTuple_SET_ITEM(tuple, 0, key); PyTuple_SET_ITEM(tuple, 1, value); *pitem = tuple; } else { if (pkey) { Py_INCREF(key); *pkey = key; } if (pvalue) { Py_INCREF(value); *pvalue = value; } } return 1; } else if (PyTuple_CheckExact(iter_obj)) { Py_ssize_t pos = *ppos; if (unlikely(pos >= PyTuple_GET_SIZE(iter_obj))) return 0; *ppos = pos + 1; next_item = PyTuple_GET_ITEM(iter_obj, pos); Py_INCREF(next_item); } else if (PyList_CheckExact(iter_obj)) { Py_ssize_t pos = *ppos; if (unlikely(pos >= PyList_GET_SIZE(iter_obj))) return 0; *ppos = pos + 1; next_item = PyList_GET_ITEM(iter_obj, pos); Py_INCREF(next_item); } else #endif { next_item = PyIter_Next(iter_obj); if (unlikely(!next_item)) { return __Pyx_IterFinish(); } } if (pitem) { *pitem = next_item; } else if (pkey && pvalue) { if (__Pyx_unpack_tuple2(next_item, pkey, pvalue, source_is_dict, source_is_dict, 1)) return -1; } else if (pkey) { *pkey = next_item; } else { *pvalue = next_item; } return 1; } /* FetchCommonType */ static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { PyObject* fake_module; PyTypeObject* cached_type = NULL; fake_module = PyImport_AddModule((char*) "_cython_" CYTHON_ABI); if (!fake_module) return NULL; Py_INCREF(fake_module); cached_type = (PyTypeObject*) PyObject_GetAttrString(fake_module, type->tp_name); if (cached_type) { if (!PyType_Check((PyObject*)cached_type)) { PyErr_Format(PyExc_TypeError, "Shared Cython type %.200s is not a type object", type->tp_name); goto bad; } if (cached_type->tp_basicsize != type->tp_basicsize) { PyErr_Format(PyExc_TypeError, "Shared Cython type %.200s has the wrong size, try recompiling", type->tp_name); goto bad; } } else { if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; PyErr_Clear(); if (PyType_Ready(type) < 0) goto bad; if (PyObject_SetAttrString(fake_module, type->tp_name, (PyObject*) type) < 0) goto bad; Py_INCREF(type); cached_type = type; } done: Py_DECREF(fake_module); return cached_type; bad: Py_XDECREF(cached_type); cached_type = NULL; goto done; } /* CythonFunction */ #include static PyObject * __Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *closure) { if (unlikely(op->func_doc == NULL)) { if (op->func.m_ml->ml_doc) { #if PY_MAJOR_VERSION >= 3 op->func_doc = PyUnicode_FromString(op->func.m_ml->ml_doc); #else op->func_doc = PyString_FromString(op->func.m_ml->ml_doc); #endif if (unlikely(op->func_doc == NULL)) return NULL; } else { Py_INCREF(Py_None); return Py_None; } } Py_INCREF(op->func_doc); return op->func_doc; } static int __Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value) { PyObject *tmp = op->func_doc; if (value == NULL) { value = Py_None; } Py_INCREF(value); op->func_doc = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op) { if (unlikely(op->func_name == NULL)) { #if PY_MAJOR_VERSION >= 3 op->func_name = PyUnicode_InternFromString(op->func.m_ml->ml_name); #else op->func_name = PyString_InternFromString(op->func.m_ml->ml_name); #endif if (unlikely(op->func_name == NULL)) return NULL; } Py_INCREF(op->func_name); return op->func_name; } static int __Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value) { PyObject *tmp; #if PY_MAJOR_VERSION >= 3 if (unlikely(value == NULL || !PyUnicode_Check(value))) { #else if (unlikely(value == NULL || !PyString_Check(value))) { #endif PyErr_SetString(PyExc_TypeError, "__name__ must be set to a string object"); return -1; } tmp = op->func_name; Py_INCREF(value); op->func_name = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op) { Py_INCREF(op->func_qualname); return op->func_qualname; } static int __Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value) { PyObject *tmp; #if PY_MAJOR_VERSION >= 3 if (unlikely(value == NULL || !PyUnicode_Check(value))) { #else if (unlikely(value == NULL || !PyString_Check(value))) { #endif PyErr_SetString(PyExc_TypeError, "__qualname__ must be set to a string object"); return -1; } tmp = op->func_qualname; Py_INCREF(value); op->func_qualname = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_CyFunction_get_self(__pyx_CyFunctionObject *m, CYTHON_UNUSED void *closure) { PyObject *self; self = m->func_closure; if (self == NULL) self = Py_None; Py_INCREF(self); return self; } static PyObject * __Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op) { if (unlikely(op->func_dict == NULL)) { op->func_dict = PyDict_New(); if (unlikely(op->func_dict == NULL)) return NULL; } Py_INCREF(op->func_dict); return op->func_dict; } static int __Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value) { PyObject *tmp; if (unlikely(value == NULL)) { PyErr_SetString(PyExc_TypeError, "function's dictionary may not be deleted"); return -1; } if (unlikely(!PyDict_Check(value))) { PyErr_SetString(PyExc_TypeError, "setting function's dictionary to a non-dict"); return -1; } tmp = op->func_dict; Py_INCREF(value); op->func_dict = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op) { Py_INCREF(op->func_globals); return op->func_globals; } static PyObject * __Pyx_CyFunction_get_closure(CYTHON_UNUSED __pyx_CyFunctionObject *op) { Py_INCREF(Py_None); return Py_None; } static PyObject * __Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op) { PyObject* result = (op->func_code) ? op->func_code : Py_None; Py_INCREF(result); return result; } static int __Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) { int result = 0; PyObject *res = op->defaults_getter((PyObject *) op); if (unlikely(!res)) return -1; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS op->defaults_tuple = PyTuple_GET_ITEM(res, 0); Py_INCREF(op->defaults_tuple); op->defaults_kwdict = PyTuple_GET_ITEM(res, 1); Py_INCREF(op->defaults_kwdict); #else op->defaults_tuple = PySequence_ITEM(res, 0); if (unlikely(!op->defaults_tuple)) result = -1; else { op->defaults_kwdict = PySequence_ITEM(res, 1); if (unlikely(!op->defaults_kwdict)) result = -1; } #endif Py_DECREF(res); return result; } static int __Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value) { PyObject* tmp; if (!value) { value = Py_None; } else if (value != Py_None && !PyTuple_Check(value)) { PyErr_SetString(PyExc_TypeError, "__defaults__ must be set to a tuple object"); return -1; } Py_INCREF(value); tmp = op->defaults_tuple; op->defaults_tuple = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op) { PyObject* result = op->defaults_tuple; if (unlikely(!result)) { if (op->defaults_getter) { if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL; result = op->defaults_tuple; } else { result = Py_None; } } Py_INCREF(result); return result; } static int __Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value) { PyObject* tmp; if (!value) { value = Py_None; } else if (value != Py_None && !PyDict_Check(value)) { PyErr_SetString(PyExc_TypeError, "__kwdefaults__ must be set to a dict object"); return -1; } Py_INCREF(value); tmp = op->defaults_kwdict; op->defaults_kwdict = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op) { PyObject* result = op->defaults_kwdict; if (unlikely(!result)) { if (op->defaults_getter) { if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL; result = op->defaults_kwdict; } else { result = Py_None; } } Py_INCREF(result); return result; } static int __Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value) { PyObject* tmp; if (!value || value == Py_None) { value = NULL; } else if (!PyDict_Check(value)) { PyErr_SetString(PyExc_TypeError, "__annotations__ must be set to a dict object"); return -1; } Py_XINCREF(value); tmp = op->func_annotations; op->func_annotations = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op) { PyObject* result = op->func_annotations; if (unlikely(!result)) { result = PyDict_New(); if (unlikely(!result)) return NULL; op->func_annotations = result; } Py_INCREF(result); return result; } static PyGetSetDef __pyx_CyFunction_getsets[] = { {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, {(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, {(char *) "__self__", (getter)__Pyx_CyFunction_get_self, 0, 0, 0}, {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, {0, 0, 0, 0, 0} }; static PyMemberDef __pyx_CyFunction_members[] = { {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), PY_WRITE_RESTRICTED, 0}, {0, 0, 0, 0, 0} }; static PyObject * __Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, CYTHON_UNUSED PyObject *args) { #if PY_MAJOR_VERSION >= 3 return PyUnicode_FromString(m->func.m_ml->ml_name); #else return PyString_FromString(m->func.m_ml->ml_name); #endif } static PyMethodDef __pyx_CyFunction_methods[] = { {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, {0, 0, 0, 0} }; #if PY_VERSION_HEX < 0x030500A0 #define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) #else #define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func.m_weakreflist) #endif static PyObject *__Pyx_CyFunction_New(PyTypeObject *type, PyMethodDef *ml, int flags, PyObject* qualname, PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { __pyx_CyFunctionObject *op = PyObject_GC_New(__pyx_CyFunctionObject, type); if (op == NULL) return NULL; op->flags = flags; __Pyx_CyFunction_weakreflist(op) = NULL; op->func.m_ml = ml; op->func.m_self = (PyObject *) op; Py_XINCREF(closure); op->func_closure = closure; Py_XINCREF(module); op->func.m_module = module; op->func_dict = NULL; op->func_name = NULL; Py_INCREF(qualname); op->func_qualname = qualname; op->func_doc = NULL; op->func_classobj = NULL; op->func_globals = globals; Py_INCREF(op->func_globals); Py_XINCREF(code); op->func_code = code; op->defaults_pyobjects = 0; op->defaults = NULL; op->defaults_tuple = NULL; op->defaults_kwdict = NULL; op->defaults_getter = NULL; op->func_annotations = NULL; PyObject_GC_Track(op); return (PyObject *) op; } static int __Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) { Py_CLEAR(m->func_closure); Py_CLEAR(m->func.m_module); Py_CLEAR(m->func_dict); Py_CLEAR(m->func_name); Py_CLEAR(m->func_qualname); Py_CLEAR(m->func_doc); Py_CLEAR(m->func_globals); Py_CLEAR(m->func_code); Py_CLEAR(m->func_classobj); Py_CLEAR(m->defaults_tuple); Py_CLEAR(m->defaults_kwdict); Py_CLEAR(m->func_annotations); if (m->defaults) { PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); int i; for (i = 0; i < m->defaults_pyobjects; i++) Py_XDECREF(pydefaults[i]); PyObject_Free(m->defaults); m->defaults = NULL; } return 0; } static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m) { if (__Pyx_CyFunction_weakreflist(m) != NULL) PyObject_ClearWeakRefs((PyObject *) m); __Pyx_CyFunction_clear(m); PyObject_GC_Del(m); } static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) { PyObject_GC_UnTrack(m); __Pyx__CyFunction_dealloc(m); } static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) { Py_VISIT(m->func_closure); Py_VISIT(m->func.m_module); Py_VISIT(m->func_dict); Py_VISIT(m->func_name); Py_VISIT(m->func_qualname); Py_VISIT(m->func_doc); Py_VISIT(m->func_globals); Py_VISIT(m->func_code); Py_VISIT(m->func_classobj); Py_VISIT(m->defaults_tuple); Py_VISIT(m->defaults_kwdict); if (m->defaults) { PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); int i; for (i = 0; i < m->defaults_pyobjects; i++) Py_VISIT(pydefaults[i]); } return 0; } static PyObject *__Pyx_CyFunction_descr_get(PyObject *func, PyObject *obj, PyObject *type) { __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; if (m->flags & __Pyx_CYFUNCTION_STATICMETHOD) { Py_INCREF(func); return func; } if (m->flags & __Pyx_CYFUNCTION_CLASSMETHOD) { if (type == NULL) type = (PyObject *)(Py_TYPE(obj)); return __Pyx_PyMethod_New(func, type, (PyObject *)(Py_TYPE(type))); } if (obj == Py_None) obj = NULL; return __Pyx_PyMethod_New(func, obj, type); } static PyObject* __Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) { #if PY_MAJOR_VERSION >= 3 return PyUnicode_FromFormat("", op->func_qualname, (void *)op); #else return PyString_FromFormat("", PyString_AsString(op->func_qualname), (void *)op); #endif } static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { PyCFunctionObject* f = (PyCFunctionObject*)func; PyCFunction meth = f->m_ml->ml_meth; Py_ssize_t size; switch (f->m_ml->ml_flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) { case METH_VARARGS: if (likely(kw == NULL || PyDict_Size(kw) == 0)) return (*meth)(self, arg); break; case METH_VARARGS | METH_KEYWORDS: return (*(PyCFunctionWithKeywords)meth)(self, arg, kw); case METH_NOARGS: if (likely(kw == NULL || PyDict_Size(kw) == 0)) { size = PyTuple_GET_SIZE(arg); if (likely(size == 0)) return (*meth)(self, NULL); PyErr_Format(PyExc_TypeError, "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", f->m_ml->ml_name, size); return NULL; } break; case METH_O: if (likely(kw == NULL || PyDict_Size(kw) == 0)) { size = PyTuple_GET_SIZE(arg); if (likely(size == 1)) { PyObject *result, *arg0; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS arg0 = PyTuple_GET_ITEM(arg, 0); #else arg0 = PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL; #endif result = (*meth)(self, arg0); #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) Py_DECREF(arg0); #endif return result; } PyErr_Format(PyExc_TypeError, "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", f->m_ml->ml_name, size); return NULL; } break; default: PyErr_SetString(PyExc_SystemError, "Bad call flags in " "__Pyx_CyFunction_Call. METH_OLDARGS is no " "longer supported!"); return NULL; } PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", f->m_ml->ml_name); return NULL; } static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { return __Pyx_CyFunction_CallMethod(func, ((PyCFunctionObject*)func)->m_self, arg, kw); } static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { PyObject *result; __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { Py_ssize_t argc; PyObject *new_args; PyObject *self; argc = PyTuple_GET_SIZE(args); new_args = PyTuple_GetSlice(args, 1, argc); if (unlikely(!new_args)) return NULL; self = PyTuple_GetItem(args, 0); if (unlikely(!self)) { Py_DECREF(new_args); return NULL; } result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); Py_DECREF(new_args); } else { result = __Pyx_CyFunction_Call(func, args, kw); } return result; } static PyTypeObject __pyx_CyFunctionType_type = { PyVarObject_HEAD_INIT(0, 0) "cython_function_or_method", sizeof(__pyx_CyFunctionObject), 0, (destructor) __Pyx_CyFunction_dealloc, 0, 0, 0, #if PY_MAJOR_VERSION < 3 0, #else 0, #endif (reprfunc) __Pyx_CyFunction_repr, 0, 0, 0, 0, __Pyx_CyFunction_CallAsMethod, 0, 0, 0, 0, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, 0, (traverseproc) __Pyx_CyFunction_traverse, (inquiry) __Pyx_CyFunction_clear, 0, #if PY_VERSION_HEX < 0x030500A0 offsetof(__pyx_CyFunctionObject, func_weakreflist), #else offsetof(PyCFunctionObject, m_weakreflist), #endif 0, 0, __pyx_CyFunction_methods, __pyx_CyFunction_members, __pyx_CyFunction_getsets, 0, 0, __Pyx_CyFunction_descr_get, 0, offsetof(__pyx_CyFunctionObject, func_dict), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, #if PY_VERSION_HEX >= 0x030400a1 0, #endif }; static int __pyx_CyFunction_init(void) { __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); if (unlikely(__pyx_CyFunctionType == NULL)) { return -1; } return 0; } static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) { __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; m->defaults = PyObject_Malloc(size); if (unlikely(!m->defaults)) return PyErr_NoMemory(); memset(m->defaults, 0, size); m->defaults_pyobjects = pyobjects; return m->defaults; } static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; m->defaults_tuple = tuple; Py_INCREF(tuple); } static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) { __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; m->defaults_kwdict = dict; Py_INCREF(dict); } static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) { __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; m->func_annotations = dict; Py_INCREF(dict); } /* FusedFunction */ static PyObject * __pyx_FusedFunction_New(PyTypeObject *type, PyMethodDef *ml, int flags, PyObject *qualname, PyObject *self, PyObject *module, PyObject *globals, PyObject *code) { __pyx_FusedFunctionObject *fusedfunc = (__pyx_FusedFunctionObject *) __Pyx_CyFunction_New(type, ml, flags, qualname, self, module, globals, code); if (!fusedfunc) return NULL; fusedfunc->__signatures__ = NULL; fusedfunc->type = NULL; fusedfunc->self = NULL; return (PyObject *) fusedfunc; } static void __pyx_FusedFunction_dealloc(__pyx_FusedFunctionObject *self) { PyObject_GC_UnTrack(self); Py_CLEAR(self->self); Py_CLEAR(self->type); Py_CLEAR(self->__signatures__); __Pyx__CyFunction_dealloc((__pyx_CyFunctionObject *) self); } static int __pyx_FusedFunction_traverse(__pyx_FusedFunctionObject *self, visitproc visit, void *arg) { Py_VISIT(self->self); Py_VISIT(self->type); Py_VISIT(self->__signatures__); return __Pyx_CyFunction_traverse((__pyx_CyFunctionObject *) self, visit, arg); } static int __pyx_FusedFunction_clear(__pyx_FusedFunctionObject *self) { Py_CLEAR(self->self); Py_CLEAR(self->type); Py_CLEAR(self->__signatures__); return __Pyx_CyFunction_clear((__pyx_CyFunctionObject *) self); } static PyObject * __pyx_FusedFunction_descr_get(PyObject *self, PyObject *obj, PyObject *type) { __pyx_FusedFunctionObject *func, *meth; func = (__pyx_FusedFunctionObject *) self; if (func->self || func->func.flags & __Pyx_CYFUNCTION_STATICMETHOD) { Py_INCREF(self); return self; } if (obj == Py_None) obj = NULL; meth = (__pyx_FusedFunctionObject *) __pyx_FusedFunction_NewEx( ((PyCFunctionObject *) func)->m_ml, ((__pyx_CyFunctionObject *) func)->flags, ((__pyx_CyFunctionObject *) func)->func_qualname, ((__pyx_CyFunctionObject *) func)->func_closure, ((PyCFunctionObject *) func)->m_module, ((__pyx_CyFunctionObject *) func)->func_globals, ((__pyx_CyFunctionObject *) func)->func_code); if (!meth) return NULL; Py_XINCREF(func->func.func_classobj); meth->func.func_classobj = func->func.func_classobj; Py_XINCREF(func->__signatures__); meth->__signatures__ = func->__signatures__; Py_XINCREF(type); meth->type = type; Py_XINCREF(func->func.defaults_tuple); meth->func.defaults_tuple = func->func.defaults_tuple; if (func->func.flags & __Pyx_CYFUNCTION_CLASSMETHOD) obj = type; Py_XINCREF(obj); meth->self = obj; return (PyObject *) meth; } static PyObject * _obj_to_str(PyObject *obj) { if (PyType_Check(obj)) return PyObject_GetAttr(obj, __pyx_n_s_name); else return PyObject_Str(obj); } static PyObject * __pyx_FusedFunction_getitem(__pyx_FusedFunctionObject *self, PyObject *idx) { PyObject *signature = NULL; PyObject *unbound_result_func; PyObject *result_func = NULL; if (self->__signatures__ == NULL) { PyErr_SetString(PyExc_TypeError, "Function is not fused"); return NULL; } if (PyTuple_Check(idx)) { PyObject *list = PyList_New(0); Py_ssize_t n = PyTuple_GET_SIZE(idx); PyObject *string = NULL; PyObject *sep = NULL; int i; if (!list) return NULL; for (i = 0; i < n; i++) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS PyObject *item = PyTuple_GET_ITEM(idx, i); #else PyObject *item = PySequence_ITEM(idx, i); #endif string = _obj_to_str(item); #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) Py_DECREF(item); #endif if (!string || PyList_Append(list, string) < 0) goto __pyx_err; Py_DECREF(string); } sep = PyUnicode_FromString("|"); if (sep) signature = PyUnicode_Join(sep, list); __pyx_err: ; Py_DECREF(list); Py_XDECREF(sep); } else { signature = _obj_to_str(idx); } if (!signature) return NULL; unbound_result_func = PyObject_GetItem(self->__signatures__, signature); if (unbound_result_func) { if (self->self || self->type) { __pyx_FusedFunctionObject *unbound = (__pyx_FusedFunctionObject *) unbound_result_func; Py_CLEAR(unbound->func.func_classobj); Py_XINCREF(self->func.func_classobj); unbound->func.func_classobj = self->func.func_classobj; result_func = __pyx_FusedFunction_descr_get(unbound_result_func, self->self, self->type); } else { result_func = unbound_result_func; Py_INCREF(result_func); } } Py_DECREF(signature); Py_XDECREF(unbound_result_func); return result_func; } static PyObject * __pyx_FusedFunction_callfunction(PyObject *func, PyObject *args, PyObject *kw) { __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; int static_specialized = (cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD && !((__pyx_FusedFunctionObject *) func)->__signatures__); if (cyfunc->flags & __Pyx_CYFUNCTION_CCLASS && !static_specialized) { return __Pyx_CyFunction_CallAsMethod(func, args, kw); } else { return __Pyx_CyFunction_Call(func, args, kw); } } static PyObject * __pyx_FusedFunction_call(PyObject *func, PyObject *args, PyObject *kw) { __pyx_FusedFunctionObject *binding_func = (__pyx_FusedFunctionObject *) func; Py_ssize_t argc = PyTuple_GET_SIZE(args); PyObject *new_args = NULL; __pyx_FusedFunctionObject *new_func = NULL; PyObject *result = NULL; PyObject *self = NULL; int is_staticmethod = binding_func->func.flags & __Pyx_CYFUNCTION_STATICMETHOD; int is_classmethod = binding_func->func.flags & __Pyx_CYFUNCTION_CLASSMETHOD; if (binding_func->self) { Py_ssize_t i; new_args = PyTuple_New(argc + 1); if (!new_args) return NULL; self = binding_func->self; #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) Py_INCREF(self); #endif Py_INCREF(self); PyTuple_SET_ITEM(new_args, 0, self); for (i = 0; i < argc; i++) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS PyObject *item = PyTuple_GET_ITEM(args, i); Py_INCREF(item); #else PyObject *item = PySequence_ITEM(args, i); if (unlikely(!item)) goto bad; #endif PyTuple_SET_ITEM(new_args, i + 1, item); } args = new_args; } else if (binding_func->type) { if (argc < 1) { PyErr_SetString(PyExc_TypeError, "Need at least one argument, 0 given."); return NULL; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS self = PyTuple_GET_ITEM(args, 0); #else self = PySequence_ITEM(args, 0); if (unlikely(!self)) return NULL; #endif } if (self && !is_classmethod && !is_staticmethod) { int is_instance = PyObject_IsInstance(self, binding_func->type); if (unlikely(!is_instance)) { PyErr_Format(PyExc_TypeError, "First argument should be of type %.200s, got %.200s.", ((PyTypeObject *) binding_func->type)->tp_name, self->ob_type->tp_name); goto bad; } else if (unlikely(is_instance == -1)) { goto bad; } } #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) Py_XDECREF(self); self = NULL; #endif if (binding_func->__signatures__) { PyObject *tup; if (is_staticmethod && binding_func->func.flags & __Pyx_CYFUNCTION_CCLASS) { tup = PyTuple_Pack(3, args, kw == NULL ? Py_None : kw, binding_func->func.defaults_tuple); if (unlikely(!tup)) goto bad; new_func = (__pyx_FusedFunctionObject *) __Pyx_CyFunction_CallMethod( func, binding_func->__signatures__, tup, NULL); } else { tup = PyTuple_Pack(4, binding_func->__signatures__, args, kw == NULL ? Py_None : kw, binding_func->func.defaults_tuple); if (unlikely(!tup)) goto bad; new_func = (__pyx_FusedFunctionObject *) __pyx_FusedFunction_callfunction(func, tup, NULL); } Py_DECREF(tup); if (unlikely(!new_func)) goto bad; Py_XINCREF(binding_func->func.func_classobj); Py_CLEAR(new_func->func.func_classobj); new_func->func.func_classobj = binding_func->func.func_classobj; func = (PyObject *) new_func; } result = __pyx_FusedFunction_callfunction(func, args, kw); bad: #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) Py_XDECREF(self); #endif Py_XDECREF(new_args); Py_XDECREF((PyObject *) new_func); return result; } static PyMemberDef __pyx_FusedFunction_members[] = { {(char *) "__signatures__", T_OBJECT, offsetof(__pyx_FusedFunctionObject, __signatures__), READONLY, 0}, {0, 0, 0, 0, 0}, }; static PyMappingMethods __pyx_FusedFunction_mapping_methods = { 0, (binaryfunc) __pyx_FusedFunction_getitem, 0, }; static PyTypeObject __pyx_FusedFunctionType_type = { PyVarObject_HEAD_INIT(0, 0) "fused_cython_function", sizeof(__pyx_FusedFunctionObject), 0, (destructor) __pyx_FusedFunction_dealloc, 0, 0, 0, #if PY_MAJOR_VERSION < 3 0, #else 0, #endif 0, 0, 0, &__pyx_FusedFunction_mapping_methods, 0, (ternaryfunc) __pyx_FusedFunction_call, 0, 0, 0, 0, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, 0, (traverseproc) __pyx_FusedFunction_traverse, (inquiry) __pyx_FusedFunction_clear, 0, 0, 0, 0, 0, __pyx_FusedFunction_members, __pyx_CyFunction_getsets, &__pyx_CyFunctionType_type, 0, __pyx_FusedFunction_descr_get, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, #if PY_VERSION_HEX >= 0x030400a1 0, #endif }; static int __pyx_FusedFunction_init(void) { __pyx_FusedFunctionType = __Pyx_FetchCommonType(&__pyx_FusedFunctionType_type); if (__pyx_FusedFunctionType == NULL) { return -1; } return 0; } /* CLineInTraceback */ #ifndef CYTHON_CLINE_IN_TRACEBACK static int __Pyx_CLineForTraceback(CYTHON_UNUSED PyThreadState *tstate, int c_line) { PyObject *use_cline; PyObject *ptype, *pvalue, *ptraceback; #if CYTHON_COMPILING_IN_CPYTHON PyObject **cython_runtime_dict; #endif if (unlikely(!__pyx_cython_runtime)) { return c_line; } __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); #if CYTHON_COMPILING_IN_CPYTHON cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); if (likely(cython_runtime_dict)) { use_cline = __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback); } else #endif { PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); if (use_cline_obj) { use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; Py_DECREF(use_cline_obj); } else { PyErr_Clear(); use_cline = NULL; } } if (!use_cline) { c_line = 0; PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); } else if (PyObject_Not(use_cline) != 0) { c_line = 0; } __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); return c_line; } #endif /* CodeObjectCache */ static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { return count; } while (start < end) { mid = start + (end - start) / 2; if (code_line < entries[mid].code_line) { end = mid; } else if (code_line > entries[mid].code_line) { start = mid + 1; } else { return mid; } } if (code_line <= entries[mid].code_line) { return mid; } else { return mid + 1; } } static PyCodeObject *__pyx_find_code_object(int code_line) { PyCodeObject* code_object; int pos; if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { return NULL; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { return NULL; } code_object = __pyx_code_cache.entries[pos].code_object; Py_INCREF(code_object); return code_object; } static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { int pos, i; __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; if (unlikely(!code_line)) { return; } if (unlikely(!entries)) { entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); if (likely(entries)) { __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = 64; __pyx_code_cache.count = 1; entries[0].code_line = code_line; entries[0].code_object = code_object; Py_INCREF(code_object); } return; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { PyCodeObject* tmp = entries[pos].code_object; entries[pos].code_object = code_object; Py_DECREF(tmp); return; } if (__pyx_code_cache.count == __pyx_code_cache.max_count) { int new_max = __pyx_code_cache.max_count + 64; entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); if (unlikely(!entries)) { return; } __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = new_max; } for (i=__pyx_code_cache.count; i>pos; i--) { entries[i] = entries[i-1]; } entries[pos].code_line = code_line; entries[pos].code_object = code_object; __pyx_code_cache.count++; Py_INCREF(code_object); } /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyObject *py_srcfile = 0; PyObject *py_funcname = 0; #if PY_MAJOR_VERSION < 3 py_srcfile = PyString_FromString(filename); #else py_srcfile = PyUnicode_FromString(filename); #endif if (!py_srcfile) goto bad; if (c_line) { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); #else py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); #endif } else { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromString(funcname); #else py_funcname = PyUnicode_FromString(funcname); #endif } if (!py_funcname) goto bad; py_code = __Pyx_PyCode_New( 0, 0, 0, 0, 0, __pyx_empty_bytes, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ __pyx_empty_tuple, /*PyObject *varnames,*/ __pyx_empty_tuple, /*PyObject *freevars,*/ __pyx_empty_tuple, /*PyObject *cellvars,*/ py_srcfile, /*PyObject *filename,*/ py_funcname, /*PyObject *name,*/ py_line, __pyx_empty_bytes /*PyObject *lnotab*/ ); Py_DECREF(py_srcfile); Py_DECREF(py_funcname); return py_code; bad: Py_XDECREF(py_srcfile); Py_XDECREF(py_funcname); return NULL; } static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyFrameObject *py_frame = 0; PyThreadState *tstate = __Pyx_PyThreadState_Current; if (c_line) { c_line = __Pyx_CLineForTraceback(tstate, c_line); } py_code = __pyx_find_code_object(c_line ? -c_line : py_line); if (!py_code) { py_code = __Pyx_CreateCodeObjectForTraceback( funcname, c_line, py_line, filename); if (!py_code) goto bad; __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); } py_frame = PyFrame_New( tstate, /*PyThreadState *tstate,*/ py_code, /*PyCodeObject *code,*/ __pyx_d, /*PyObject *globals,*/ 0 /*PyObject *locals*/ ); if (!py_frame) goto bad; __Pyx_PyFrame_SetLineNumber(py_frame, py_line); PyTraceBack_Here(py_frame); bad: Py_XDECREF(py_code); Py_XDECREF(py_frame); } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { const long neg_one = (long) -1, const_zero = (long) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(long) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(long) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(long) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); } } /* CIntFromPyVerify */ #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) #define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) #define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ {\ func_type value = func_value;\ if (sizeof(target_type) < sizeof(func_type)) {\ if (unlikely(value != (func_type) (target_type) value)) {\ func_type zero = 0;\ if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ return (target_type) -1;\ if (is_unsigned && unlikely(value < zero))\ goto raise_neg_overflow;\ else\ goto raise_overflow;\ }\ }\ return (target_type) value;\ } /* Import */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { PyObject *empty_list = 0; PyObject *module = 0; PyObject *global_dict = 0; PyObject *empty_dict = 0; PyObject *list; #if PY_MAJOR_VERSION < 3 PyObject *py_import; py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); if (!py_import) goto bad; #endif if (from_list) list = from_list; else { empty_list = PyList_New(0); if (!empty_list) goto bad; list = empty_list; } global_dict = PyModule_GetDict(__pyx_m); if (!global_dict) goto bad; empty_dict = PyDict_New(); if (!empty_dict) goto bad; { #if PY_MAJOR_VERSION >= 3 if (level == -1) { if (strchr(__Pyx_MODULE_NAME, '.')) { module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, 1); if (!module) { if (!PyErr_ExceptionMatches(PyExc_ImportError)) goto bad; PyErr_Clear(); } } level = 0; } #endif if (!module) { #if PY_MAJOR_VERSION < 3 PyObject *py_level = PyInt_FromLong(level); if (!py_level) goto bad; module = PyObject_CallFunctionObjArgs(py_import, name, global_dict, empty_dict, list, py_level, NULL); Py_DECREF(py_level); #else module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, level); #endif } } bad: #if PY_MAJOR_VERSION < 3 Py_XDECREF(py_import); #endif Py_XDECREF(empty_list); Py_XDECREF(empty_dict); return module; } /* CIntFromPy */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { const long neg_one = (long) -1, const_zero = (long) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(long) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (long) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (long) 0; case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) case 2: if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 3: if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 4: if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (long) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(long) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (long) 0; case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) case -2: if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 2: if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -3: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 3: if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -4: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 4: if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; } #endif if (sizeof(long) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else long val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (long) -1; } } else { long val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (long) -1; val = __Pyx_PyInt_As_long(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to long"); return (long) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to long"); return (long) -1; } /* ImportNumPyArray */ static PyObject* __Pyx__ImportNumPyArray(void) { PyObject *numpy_module, *ndarray_object = NULL; numpy_module = __Pyx_Import(__pyx_n_s_numpy, NULL, 0); if (likely(numpy_module)) { ndarray_object = PyObject_GetAttrString(numpy_module, "ndarray"); Py_DECREF(numpy_module); } if (unlikely(!ndarray_object)) { PyErr_Clear(); } if (unlikely(!ndarray_object || !PyObject_TypeCheck(ndarray_object, &PyType_Type))) { Py_XDECREF(ndarray_object); Py_INCREF(Py_None); ndarray_object = Py_None; } return ndarray_object; } static CYTHON_INLINE PyObject* __Pyx_ImportNumPyArrayTypeIfAvailable(void) { if (unlikely(!__pyx_numpy_ndarray)) { __pyx_numpy_ndarray = __Pyx__ImportNumPyArray(); } Py_INCREF(__pyx_numpy_ndarray); return __pyx_numpy_ndarray; } /* CIntFromPy */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { const int neg_one = (int) -1, const_zero = (int) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(int) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (int) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (int) 0; case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) case 2: if (8 * sizeof(int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 3: if (8 * sizeof(int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 4: if (8 * sizeof(int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (int) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(int) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (int) 0; case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) case -2: if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 2: if (8 * sizeof(int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -3: if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 3: if (8 * sizeof(int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -4: if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 4: if (8 * sizeof(int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; } #endif if (sizeof(int) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (int) -1; } } else { int val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (int) -1; val = __Pyx_PyInt_As_int(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to int"); return (int) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to int"); return (int) -1; } /* FastTypeChecks */ #if CYTHON_COMPILING_IN_CPYTHON static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { while (a) { a = a->tp_base; if (a == b) return 1; } return b == &PyBaseObject_Type; } static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { PyObject *mro; if (a == b) return 1; mro = a->tp_mro; if (likely(mro)) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(mro); for (i = 0; i < n; i++) { if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) return 1; } return 0; } return __Pyx_InBases(a, b); } #if PY_MAJOR_VERSION == 2 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { PyObject *exception, *value, *tb; int res; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ErrFetch(&exception, &value, &tb); res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } if (!res) { res = PyObject_IsSubclass(err, exc_type2); if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } } __Pyx_ErrRestore(exception, value, tb); return res; } #else static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; if (!res) { res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); } return res; } #endif static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; assert(PyExceptionClass_Check(exc_type)); n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; ip) { #if PY_MAJOR_VERSION < 3 if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { *t->p = PyString_InternFromString(t->s); } else { *t->p = PyString_FromStringAndSize(t->s, t->n - 1); } #else if (t->is_unicode | t->is_str) { if (t->intern) { *t->p = PyUnicode_InternFromString(t->s); } else if (t->encoding) { *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); } else { *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); } } else { *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); } #endif if (!*t->p) return -1; if (PyObject_Hash(*t->p) == -1) return -1; ++t; } return 0; } static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); } static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; return __Pyx_PyObject_AsStringAndSize(o, &ignore); } #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT #if !CYTHON_PEP393_ENABLED static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { char* defenc_c; PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); if (!defenc) return NULL; defenc_c = PyBytes_AS_STRING(defenc); #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII { char* end = defenc_c + PyBytes_GET_SIZE(defenc); char* c; for (c = defenc_c; c < end; c++) { if ((unsigned char) (*c) >= 128) { PyUnicode_AsASCIIString(o); return NULL; } } } #endif *length = PyBytes_GET_SIZE(defenc); return defenc_c; } #else static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII if (likely(PyUnicode_IS_ASCII(o))) { *length = PyUnicode_GET_LENGTH(o); return PyUnicode_AsUTF8(o); } else { PyUnicode_AsASCIIString(o); return NULL; } #else return PyUnicode_AsUTF8AndSize(o, length); #endif } #endif #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT if ( #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII __Pyx_sys_getdefaultencoding_not_ascii && #endif PyUnicode_Check(o)) { return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif #if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); } else #endif { char* result; int r = PyBytes_AsStringAndSize(o, &result, length); if (unlikely(r < 0)) { return NULL; } else { return result; } } } static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { int is_true = x == Py_True; if (is_true | (x == Py_False) | (x == Py_None)) return is_true; else return PyObject_IsTrue(x); } static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(result)) { if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, "__int__ returned non-int (type %.200s). " "The ability to return an instance of a strict subclass of int " "is deprecated, and may be removed in a future version of Python.", Py_TYPE(result)->tp_name)) { Py_DECREF(result); return NULL; } return result; } #endif PyErr_Format(PyExc_TypeError, "__%.4s__ returned non-%.4s (type %.200s)", type_name, type_name, Py_TYPE(result)->tp_name); Py_DECREF(result); return NULL; } static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { #if CYTHON_USE_TYPE_SLOTS PyNumberMethods *m; #endif const char *name = NULL; PyObject *res = NULL; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x) || PyLong_Check(x))) #else if (likely(PyLong_Check(x))) #endif return __Pyx_NewRef(x); #if CYTHON_USE_TYPE_SLOTS m = Py_TYPE(x)->tp_as_number; #if PY_MAJOR_VERSION < 3 if (m && m->nb_int) { name = "int"; res = m->nb_int(x); } else if (m && m->nb_long) { name = "long"; res = m->nb_long(x); } #else if (likely(m && m->nb_int)) { name = "int"; res = m->nb_int(x); } #endif #else if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { res = PyNumber_Int(x); } #endif if (likely(res)) { #if PY_MAJOR_VERSION < 3 if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { #else if (unlikely(!PyLong_CheckExact(res))) { #endif return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); } } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_TypeError, "an integer is required"); } return res; } static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { Py_ssize_t ival; PyObject *x; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(b))) { if (sizeof(Py_ssize_t) >= sizeof(long)) return PyInt_AS_LONG(b); else return PyInt_AsSsize_t(x); } #endif if (likely(PyLong_CheckExact(b))) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)b)->ob_digit; const Py_ssize_t size = Py_SIZE(b); if (likely(__Pyx_sst_abs(size) <= 1)) { ival = likely(size) ? digits[0] : 0; if (size == -1) ival = -ival; return ival; } else { switch (size) { case 2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; } } #endif return PyLong_AsSsize_t(b); } x = PyNumber_Index(b); if (!x) return -1; ival = PyInt_AsSsize_t(x); Py_DECREF(x); return ival; } static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); } static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { return PyInt_FromSize_t(ival); } #endif /* Py_PYTHON_H */ ================================================ FILE: ci/testdata/cython_test.pyx ================================================ """ simple test file for cython source mapping: defines a function that uses newtowns method to compute the square root of a number """ from cython cimport floating cpdef sqrt(floating value): # solve for the square root of value by finding the zeros of # 'x * x - value = 0' using newtons method cdef double x = value / 2 for _ in range(8): x -= (x * x - value) / (2 * x) return x ================================================ FILE: ci/update_python_test_versions.py ================================================ from collections import defaultdict import requests import pathlib import yaml import re _VERSIONS_URL = "https://raw.githubusercontent.com/actions/python-versions/main/versions-manifest.json" # noqa def parse_version(v): return tuple(int(part) for part in re.split(r"\W", v)[:3]) def get_github_python_versions(): versions_json = requests.get(_VERSIONS_URL).json() # windows platform support isn't great for older versions of python # get a map of version: platform/arch so we can exclude here platforms = {} for v in versions_json: version_platforms = set() for f in v["files"]: platform, arch = f["platform"], f["arch"] if platform == "linux" and f.get("platform_version") != "22.04": continue version_platforms.add((platform, arch)) platforms[v["version"]] = version_platforms raw_versions = [v["version"] for v in versions_json] minor_versions = defaultdict(list) for version_str in raw_versions: if "-" in version_str: continue major, minor, patch = parse_version(version_str) if major == 3 and minor < 6: # we don't support python 3.0/3.1/3.2 , and don't bother testing 3.3/3.4/3.5 continue elif major == 2 and minor < 7: # we don't test python support before 2.7 continue minor_versions[(major, minor)].append(patch) versions = [] for (major, minor), patches in minor_versions.items(): patches.sort() # for older versions of python, don't test all patches # (just test first and last) to keep the test matrix down if major == 2 or minor <= 11: patches = [patches[0], patches[-1]] if major == 3 and minor > 13: continue versions.extend(f"{major}.{minor}.{patch}" for patch in patches) return versions, platforms def update_python_test_versions(): versions, platforms = get_github_python_versions() versions = sorted(versions, key=parse_version) build_yml_path = ( pathlib.Path(__file__).parent.parent / ".github" / "workflows" / "build.yml" ) build_yml = yaml.safe_load(open(build_yml_path)) test_matrix = build_yml["jobs"]["test-wheels"]["strategy"]["matrix"] existing_python_versions = test_matrix["python-version"] if versions == existing_python_versions: return print("Adding new versions") print("Old:", existing_python_versions) print("New:", versions) # we can't use the yaml package to update the GHA script, since # the data in build_yml is treated as an unordered dictionary. # instead modify the file in place lines = list(open(build_yml_path)) first_line = lines.index( " # automatically generated by ci/update_python_test_versions.py\n" ) first_version_line = lines.index(" [\n", first_line) last_version_line = lines.index(" ]\n", first_version_line) new_versions = [f" {v},\n" for v in versions] lines = lines[: first_version_line + 1] + new_versions + lines[last_version_line:] # also automatically exclude >= v3.11.* from running on OSX, # since it currently fails in GHA on SIP errors exclusions = [] for v in versions: # if we don't have a python version for osx/windows skip if ("darwin", "x64") not in platforms[v] or v.startswith("3.12"): exclusions.append(" - os: macos-13\n") exclusions.append(f" python-version: {v}\n") if ("win32", "x64") not in platforms[v]: exclusions.append(" - os: windows-latest\n") exclusions.append(f" python-version: {v}\n") if ("linux", "x64") not in platforms[v]: exclusions.append(" - os: ubuntu-22.04\n") exclusions.append(f" python-version: {v}\n") if ("linux", "arm64") not in platforms[v]: exclusions.append(" - os: ubuntu-22.04-arm\n") exclusions.append(f" python-version: {v}\n") first_exclude_line = lines.index(" exclude:\n", first_line) last_exclude_line = lines.index("\n", first_exclude_line) lines = lines[: first_exclude_line + 1] + exclusions + lines[last_exclude_line:] with open(build_yml_path, "w") as o: o.write("".join(lines)) if __name__ == "__main__": update_python_test_versions() ================================================ FILE: examples/dump_traces.rs ================================================ use log::error; // Simple example of showing how to use the rust API to // print out stack traces from a python program fn print_python_stacks(pid: remoteprocess::Pid) -> Result<(), anyhow::Error> { // Create a new PythonSpy object with the default config options let config = py_spy::Config::default(); let mut process = py_spy::PythonSpy::new(pid, &config)?; // get stack traces for each thread in the process let traces = process.get_stack_traces()?; // Print out the python stack for each thread for trace in traces { println!("Thread {:#X} ({})", trace.thread_id, trace.status_str()); for frame in &trace.frames { println!("\t {} ({}:{})", frame.name, frame.filename, frame.line); } } Ok(()) } fn main() { env_logger::init(); let args: Vec = std::env::args().collect(); let pid = if args.len() > 1 { args[1].parse().expect("invalid pid") } else { error!("you must specify a pid!"); return; }; if let Err(e) = print_python_stacks(pid) { error!("failed to print stack traces: {:?}", e); } } ================================================ FILE: generate_bindings.py ================================================ """ Scripts to generate bindings of different python interpreter versions Requires bindgen to be installed (cargo install bindgen), and probably needs a nightly compiler with rustfmt-nightly. Also requires a git repo of cpython to be checked out somewhere. As a hack, this can also build different versions of cpython for testing out """ import argparse import os import sys import tempfile def build_python(cpython_path, version): # TODO: probably easier to use pyenv for this? print("Compiling python %s from repo at %s" % (version, cpython_path)) install_path = os.path.abspath(os.path.join(cpython_path, version)) ret = os.system( f""" cd {cpython_path} git checkout {version} # build in a subdirectory mkdir -p build_{version} cd build_{version} ../configure prefix={install_path} make make install """ ) if ret: return ret # also install setuptools_rust/wheel here for building packages pip = os.path.join(install_path, "bin", "pip3" if version.startswith("v3") else "pip") return os.system(f"{pip} install setuptools_rust wheel") def calculate_pyruntime_offsets(cpython_path, version, configure=False): ret = os.system(f"""cd {cpython_path} && git checkout {version}""") if ret: return ret if configure: os.system(f"cd {cpython_path} && ./configure prefix=" + os.path.abspath(os.path.join(cpython_path, version))) # simple little c program to get the offsets we need from the pyruntime struct # (using rust bindgen here is more complicated than necessary) program = r""" #include #include #define Py_BUILD_CORE 1 #include "Include/Python.h" #include "Include/internal/pystate.h" int main(int argc, const char * argv[]) { size_t interp_head = offsetof(_PyRuntimeState, interpreters.head); printf("pub static INTERP_HEAD_OFFSET: usize = %i;\n", interp_head); // tstate_current has been replaced by a thread-local variable in python 3.12 // size_t tstate_current = offsetof(_PyRuntimeState, gilstate.tstate_current); // printf("pub static TSTATE_CURRENT: usize = %i;\n", tstate_current); } """ if not os.path.isfile(os.path.join(cpython_path, "Include", "internal", "pystate.h")): if os.path.isfile(os.path.join(cpython_path, "Include", "internal", "pycore_pystate.h")): program = program.replace("pystate.h", "pycore_pystate.h") else: print("failed to find Include/internal/pystate.h in cpython directory =(") return with tempfile.TemporaryDirectory() as path: if sys.platform.startswith("win"): source_filename = os.path.join(path, "pyruntime_offsets.cpp") exe = os.path.join("pyruntime_offsets.exe") else: source_filename = os.path.join(path, "pyruntime_offsets.c") exe = os.path.join(path, "pyruntime_offsets") with open(source_filename, "w") as o: o.write(program) if sys.platform.startswith("win"): # this requires a 'x64 Native Tools Command Prompt' to work out properly for 64 bit installs # also expects that you have run something like 'PCBuild\build.bat' first ret = os.system(f"cl {source_filename} /I {cpython_path} /I {cpython_path}\PC /I {cpython_path}\Include") elif sys.platform.startswith("freebsd"): ret = os.system(f"""cc {source_filename} -I {cpython_path} -I {cpython_path}/Include -o {exe}""") else: ret = os.system(f"""gcc {source_filename} -I {cpython_path} -I {cpython_path}/Include -o {exe}""") if ret: print("Failed to compile") return ret ret = os.system(exe) if ret: print("Failed to run pyruntime file") return ret def extract_bindings(cpython_path, version, configure=False): print("Generating bindings for python %s from repo at %s" % (version, cpython_path)) ret = os.system( f""" cd {cpython_path} git checkout {version} # need to run configure on the current branch to generate pyconfig.h sometimes {("./configure prefix=" + os.path.abspath(os.path.join(cpython_path, version))) if configure else ""} echo "// autogenerated by generate_bindings.py " > bindgen_input.h echo '#define Py_BUILD_CORE 1\n' >> bindgen_input.h cat Include/Python.h >> bindgen_input.h echo '#undef HAVE_STD_ATOMIC' >> bindgen_input.h cat Include/frameobject.h >> bindgen_input.h cat Include/internal/pycore_interp.h >> bindgen_input.h cat Include/internal/pycore_dict.h >> bindgen_input.h cat Include/internal/pycore_frame.h >> bindgen_input.h bindgen bindgen_input.h -o bindgen_output.rs \ --with-derive-default \ --no-layout-tests --no-doc-comments \ --allowlist-type PyInterpreterState \ --allowlist-type PyFrameObject \ --allowlist-type PyThreadState \ --allowlist-type PyCodeObject \ --allowlist-type PyVarObject \ --allowlist-type PyBytesObject \ --allowlist-type PyASCIIObject \ --allowlist-type PyUnicodeObject \ --allowlist-type PyCompactUnicodeObject \ --allowlist-type PyTupleObject \ --allowlist-type PyListObject \ --allowlist-type PyLongObject \ --allowlist-type PyFloatObject \ --allowlist-type PyDictObject \ --allowlist-type PyDictKeysObject \ --allowlist-type PyDictUnicodeEntry \ --allowlist-type PyObject \ --allowlist-type PyTypeObject \ --allowlist-type PyHeapTypeObject \ --allowlist-type PyInterpreterFrame \ -- -I . -I ./Include -I ./Include/internal """ ) if ret: return ret # write the file out to the appropriate place, disabling some warnings with open(os.path.join("src", "python_bindings", version.replace(".", "_") + ".rs"), "w") as o: o.write(f"// Generated bindings for python {version}\n") o.write("#![allow(dead_code)]\n") o.write("#![allow(non_upper_case_globals)]\n") o.write("#![allow(non_camel_case_types)]\n") o.write("#![allow(non_snake_case)]\n") o.write("#![allow(clippy::useless_transmute)]\n") o.write("#![allow(clippy::default_trait_access)]\n") o.write("#![allow(clippy::cast_lossless)]\n") o.write("#![allow(clippy::trivially_copy_pass_by_ref)]\n") o.write("#![allow(clippy::upper_case_acronyms)]\n") o.write("#![allow(clippy::too_many_arguments)]\n\n") o.write(open(os.path.join(cpython_path, "bindgen_output.rs")).read()) if __name__ == "__main__": if sys.platform.startswith("win"): default_cpython_path = os.path.join(os.getenv("userprofile"), "code", "cpython") else: default_cpython_path = os.path.join(os.getenv("HOME"), "code", "cpython") parser = argparse.ArgumentParser( description="runs bindgen on cpython version", formatter_class=argparse.ArgumentDefaultsHelpFormatter, ) parser.add_argument( "--cpython", type=str, default=default_cpython_path, dest="cpython", help="path to cpython repo", ) parser.add_argument( "--configure", help="Run configure script prior to generating bindings", action="store_true", ) parser.add_argument("--pyruntime", help="generate offsets for pyruntime", action="store_true") parser.add_argument("--build", help="Build python for this version", action="store_true") parser.add_argument("--all", help="Build all versions", action="store_true") parser.add_argument("versions", type=str, nargs="*", help="versions to extract") args = parser.parse_args() if not os.path.isdir(args.cpython): print(f"Directory '{args.cpython}' doesn't exist!") print("Pass a valid cpython path in with --cpython ") sys.exit(1) if args.all: versions = [ "v3.13.0", "v3.12.0", "v3.11.0", "v3.10.0", "v3.9.0", "v3.8.0", "v3.7.0", "v3.6.6", "v3.5.5", "v3.4.8", "v3.3.7", "v3.2.6", "v2.7.15", ] else: versions = args.versions if not versions: print("You must specify versions of cpython to generate bindings for, or --all\n") parser.print_help() for version in versions: if args.build: # todo: this probably should be a separate script if build_python(args.cpython, version): print("Failed to build python") elif args.pyruntime: calculate_pyruntime_offsets(args.cpython, version, configure=args.configure) else: if extract_bindings(args.cpython, version, configure=args.configure): print("Failed to generate bindings") ================================================ FILE: pyproject.toml ================================================ [build-system] requires = ["maturin>=1.0,<2.0"] build-backend = "maturin" [project] name = "py-spy" classifiers = [ "Development Status :: 5 - Production/Stable", "Programming Language :: Python :: 3", "Programming Language :: Python :: 2", "Intended Audience :: Developers", "License :: OSI Approved :: MIT License", "Topic :: Software Development :: Libraries", "Topic :: Utilities" ] dynamic = ["version"] [project.optional-dependencies] test = ["numpy"] [tool.maturin] bindings = "bin" [tool.codespell] ignore-words-list = "crate" skip = "./.git,./.github,./target,./ci/testdata,./images/" ================================================ FILE: setup.cfg ================================================ [bumpversion] current_version = 0.4.1 commit = True tag = True parse = (?P\d+)\.(?P\d+)\.(?P\d+)((?P(a|b|rc|\.dev)\d+))? serialize = {major}.{minor}.{patch}{release} {major}.{minor}.{patch} [bumpversion:file:Cargo.toml] search = name = "py-spy" version = "{current_version}" replace = name = "py-spy" version = "{new_version}" [bumpversion:file:Cargo.lock] search = name = "py-spy" version = "{current_version}" replace = name = "py-spy" version = "{new_version}" [flake8] max-line-length = 100 exclude = build,.eggs,.tox ================================================ FILE: src/binary_parser.rs ================================================ use std::collections::HashMap; use std::fs::File; use std::path::Path; use anyhow::Error; use goblin::Object; use memmap2::Mmap; use crate::utils::is_subrange; pub struct BinaryInfo { pub symbols: HashMap, pub bss_addr: u64, pub bss_size: u64, pub pyruntime_addr: u64, pub pyruntime_size: u64, #[allow(dead_code)] pub addr: u64, #[allow(dead_code)] pub size: u64, } impl BinaryInfo { #[cfg(feature = "unwind")] pub fn contains(&self, addr: u64) -> bool { addr >= self.addr && addr < (self.addr + self.size) } } /// Uses goblin to parse a binary file, returns information on symbols/bss/adjusted offset etc pub fn parse_binary(filename: &Path, addr: u64, size: u64) -> Result { let offset = addr; let mut symbols = HashMap::new(); // Read in the filename let file = File::open(filename)?; let buffer = unsafe { Mmap::map(&file)? }; // Use goblin to parse the binary match Object::parse(&buffer)? { Object::Mach(mach) => { // Get the mach binary from the archive let mach = match mach { goblin::mach::Mach::Binary(mach) => mach, goblin::mach::Mach::Fat(fat) => { let arch = fat .iter_arches() .find(|arch| match arch { Ok(arch) => arch.is_64(), Err(_) => false, }) .ok_or_else(|| { format_err!( "Failed to find 64 bit arch in FAT archive in {}", filename.display() ) })??; if !is_subrange(0, buffer.len(), arch.offset as usize, arch.size as usize) { return Err(format_err!( "Invalid offset/size in FAT archive in {}", filename.display() )); } let bytes = &buffer[arch.offset as usize..][..arch.size as usize]; goblin::mach::MachO::parse(bytes, 0)? } }; let mut pyruntime_addr = 0; let mut pyruntime_size = 0; let mut bss_addr = 0; let mut bss_size = 0; for segment in mach.segments.iter() { for (section, _) in &segment.sections()? { let name = section.name()?; if name == "PyRuntime" { if let Some(addr) = section.addr.checked_add(offset) { if addr.checked_add(section.size).is_some() { pyruntime_addr = addr; pyruntime_size = section.size; } } } if name == "__bss" { if let Some(addr) = section.addr.checked_add(offset) { if addr.checked_add(section.size).is_some() { bss_addr = addr; bss_size = section.size; } } } } } if let Some(syms) = mach.symbols { for symbol in syms.iter() { let (name, value) = symbol?; // almost every symbol we care about starts with an extra _, remove to normalize // with the entries seen on linux/windows if let Some(stripped_name) = name.strip_prefix('_') { symbols.insert(stripped_name.to_string(), value.n_value + offset); } } } Ok(BinaryInfo { symbols, bss_addr, bss_size, pyruntime_addr, pyruntime_size, addr, size, }) } Object::Elf(elf) => { let strtab = elf.shdr_strtab; let bss_header = elf .section_headers .iter() // filter down to things that are both NOBITS sections and are named .bss .filter(|header| header.sh_type == goblin::elf::section_header::SHT_NOBITS) .filter(|header| { strtab .get_at(header.sh_name) .is_none_or(|name| name == ".bss") }) // if we have multiple sections here, take the largest .max_by_key(|header| header.sh_size) .ok_or_else(|| { format_err!( "Failed to find BSS section header in {}", filename.display() ) })?; let program_header = elf .program_headers .iter() .find(|header| { header.p_type == goblin::elf::program_header::PT_LOAD && header.p_flags & goblin::elf::program_header::PF_X != 0 }) .ok_or_else(|| { format_err!( "Failed to find executable PT_LOAD program header in {}", filename.display() ) })?; // Align the virtual address offset, then subtract it from the offset // to get real offset for symbol addresses in the file. let aligned_vaddr = program_header.p_vaddr - (program_header.p_vaddr % page_size::get() as u64); let offset = offset.saturating_sub(aligned_vaddr); let mut bss_addr = 0; let mut bss_size = 0; let mut bss_end = 0; if let Some(addr) = bss_header.sh_addr.checked_add(offset) { if bss_header.sh_size.checked_add(addr).is_none() { return Err(format_err!( "Invalid bss address/size in {}", filename.display() )); } bss_addr = addr; bss_size = bss_header.sh_size; bss_end = bss_header.sh_addr + bss_header.sh_size; } let pyruntime_header = elf .section_headers .iter() .find(|header| strtab.get_at(header.sh_name) == Some(".PyRuntime")); let mut pyruntime_addr = 0; let mut pyruntime_size = 0; if let Some(header) = pyruntime_header { if let Some(addr) = header.sh_addr.checked_add(offset) { pyruntime_addr = addr; pyruntime_size = header.sh_size; } } for sym in elf.syms.iter() { // Skip undefined symbols. if sym.st_shndx == goblin::elf::section_header::SHN_UNDEF as usize { continue; } // Skip imported symbols if sym.is_import() || (bss_end != 0 && sym.st_size != 0 && !is_subrange(0u64, bss_end, sym.st_value, sym.st_size)) { continue; } if let Some(pos) = sym.st_value.checked_add(offset) { if sym.is_function() && !is_subrange(addr, size, pos, sym.st_size) { continue; } if let Some(name) = elf.strtab.get_unsafe(sym.st_name) { symbols.insert(name.to_string(), pos); } } } for dynsym in elf.dynsyms.iter() { // Skip undefined symbols. if dynsym.st_shndx == goblin::elf::section_header::SHN_UNDEF as usize { continue; } // Skip imported symbols if dynsym.is_import() || (bss_end != 0 && dynsym.st_size != 0 && !is_subrange(0u64, bss_end, dynsym.st_value, dynsym.st_size)) { continue; } if let Some(pos) = dynsym.st_value.checked_add(offset) { if dynsym.is_function() && !is_subrange(addr, size, pos, dynsym.st_size) { continue; } if let Some(name) = elf.dynstrtab.get_unsafe(dynsym.st_name) { symbols.insert(name.to_string(), pos); } } } Ok(BinaryInfo { symbols, bss_addr, bss_size, pyruntime_addr, pyruntime_size, addr, size, }) } Object::PE(pe) => { for export in pe.exports { if let Some(name) = export.name { if let Some(addr) = offset.checked_add(export.rva as u64) { symbols.insert(name.to_string(), addr); } } } let mut bss_addr = 0; let mut bss_size = 0; let mut pyruntime_addr = 0; let mut pyruntime_size = 0; let mut found_data = false; for section in pe.sections.iter() { if section.name.starts_with(b".data") { found_data = true; if let Some(addr) = offset.checked_add(section.virtual_address as u64) { if addr.checked_add(section.virtual_size as u64).is_some() { bss_addr = addr; bss_size = u64::from(section.virtual_size); } } } else if section.name.starts_with(b"PyRuntim") { // note that the name is only 8 chars here, so we don't check for // trailing 'e' in PyRuntime if let Some(addr) = offset.checked_add(section.virtual_address as u64) { if addr.checked_add(section.virtual_size as u64).is_some() { pyruntime_addr = addr; pyruntime_size = u64::from(section.virtual_size); } } } } if !found_data { return Err(format_err!( "Failed to find .data section in PE binary of {}", filename.display() )); } Ok(BinaryInfo { symbols, bss_addr, bss_size, pyruntime_size, pyruntime_addr, addr, size, }) } _ => Err(format_err!("Unhandled binary type")), } } ================================================ FILE: src/chrometrace.rs ================================================ use std::cmp::min; use std::collections::HashMap; use std::io::Write; use std::time::Instant; use anyhow::Error; use serde_derive::Serialize; use crate::stack_trace::Frame; use crate::stack_trace::StackTrace; #[derive(Clone, Debug, Serialize)] struct Args { pub filename: String, pub line: Option, } #[derive(Clone, Debug, Serialize)] struct Event { pub args: Args, pub cat: String, pub name: String, pub ph: String, pub pid: u64, pub tid: u64, pub ts: u64, } pub struct Chrometrace { events: Vec, start_ts: Instant, prev_traces: HashMap, show_linenumbers: bool, } impl Chrometrace { pub fn new(show_linenumbers: bool) -> Chrometrace { Chrometrace { events: Vec::new(), start_ts: Instant::now(), prev_traces: HashMap::new(), show_linenumbers, } } // Return whether these frames are similar enough such that we should merge // them, instead of creating separate events for them. fn should_merge_frames(&self, a: &Frame, b: &Frame) -> bool { a.name == b.name && a.filename == b.filename && (!self.show_linenumbers || a.line == b.line) } fn event(&self, trace: &StackTrace, frame: &Frame, phase: &str, ts: u64) -> Event { Event { tid: trace.thread_id, pid: trace.pid as u64, name: frame.name.to_string(), cat: "py-spy".to_owned(), ph: phase.to_owned(), ts, args: Args { filename: frame.filename.to_string(), line: if self.show_linenumbers { Some(frame.line as u32) } else { None }, }, } } pub fn increment(&mut self, trace: &StackTrace) -> std::io::Result<()> { let now = self.start_ts.elapsed().as_micros() as u64; // Load the previous frames for this thread. let prev_frames = self .prev_traces .remove(&trace.thread_id) .map(|t| t.frames) .unwrap_or_default(); // Find the index where we first see new frames. let new_idx = prev_frames .iter() .rev() .zip(trace.frames.iter().rev()) .position(|(a, b)| !self.should_merge_frames(a, b)) .unwrap_or(min(prev_frames.len(), trace.frames.len())); // Publish end events for the previous frames that got dropped in the // most recent trace. for frame in prev_frames.iter().rev().skip(new_idx).rev() { self.events.push(self.event(trace, frame, "E", now)); } // Publish start events for frames that got added in the most recent // trace. for frame in trace.frames.iter().rev().skip(new_idx) { self.events.push(self.event(trace, frame, "B", now)); } // Save this stack trace for the next iteration. self.prev_traces.insert(trace.thread_id, trace.clone()); Ok(()) } pub fn write(&self, w: &mut dyn Write) -> Result<(), Error> { let mut events = Vec::new(); events.extend(self.events.to_vec()); // Add end events for any unfinished slices. let now = self.start_ts.elapsed().as_micros() as u64; for trace in self.prev_traces.values() { for frame in &trace.frames { events.push(self.event(trace, frame, "E", now)); } } writeln!(w, "{}", serde_json::to_string(&events)?)?; Ok(()) } } ================================================ FILE: src/config.rs ================================================ use clap::{ crate_description, crate_name, crate_version, value_parser, Arg, ArgEnum, Command, PossibleValue, }; use remoteprocess::Pid; /// Options on how to collect samples from a python process #[derive(Debug, Clone, PartialEq)] pub struct Config { /// Whether or not we should stop the python process when taking samples. /// Setting this to false will reduce the performance impact on the target /// python process, but can lead to incorrect results like partial stack /// traces being returned or a higher sampling error rate pub blocking: LockingStrategy, /// Whether or not to profile native extensions. Note: this option can not be /// used with the nonblocking option, as we have to pause the process to collect /// the native stack traces pub native: bool, // The following config options only apply when using py-spy as an application #[doc(hidden)] pub command: String, #[doc(hidden)] pub pid: Option, #[doc(hidden)] pub python_program: Option>, #[doc(hidden)] pub sampling_rate: u64, #[doc(hidden)] pub filename: Option, #[doc(hidden)] pub format: Option, #[doc(hidden)] pub show_line_numbers: bool, #[doc(hidden)] pub duration: RecordDuration, #[doc(hidden)] pub include_idle: bool, #[doc(hidden)] pub include_thread_ids: bool, #[doc(hidden)] pub subprocesses: bool, #[doc(hidden)] pub gil_only: bool, #[doc(hidden)] pub hide_progress: bool, #[doc(hidden)] pub capture_output: bool, #[doc(hidden)] pub dump_json: bool, #[doc(hidden)] pub dump_locals: u64, #[doc(hidden)] pub full_filenames: bool, #[doc(hidden)] pub lineno: LineNo, #[doc(hidden)] pub refresh_seconds: f64, #[doc(hidden)] pub core_filename: Option, } #[allow(non_camel_case_types)] #[derive(ArgEnum, Debug, Copy, Clone, Eq, PartialEq)] pub enum FileFormat { flamegraph, raw, speedscope, chrometrace, } impl FileFormat { pub fn possible_values() -> impl Iterator> { FileFormat::value_variants() .iter() .filter_map(ArgEnum::to_possible_value) } } impl std::str::FromStr for FileFormat { type Err = String; fn from_str(s: &str) -> Result { for variant in Self::value_variants() { if variant.to_possible_value().unwrap().matches(s, false) { return Ok(*variant); } } Err(format!("Invalid fileformat: {s}")) } } #[derive(Debug, Clone, Eq, PartialEq)] pub enum LockingStrategy { NonBlocking, #[allow(dead_code)] AlreadyLocked, Lock, } #[derive(Debug, Clone, Eq, PartialEq)] pub enum RecordDuration { Unlimited, Seconds(u64), } #[derive(Debug, Clone, Eq, PartialEq, Copy)] pub enum LineNo { NoLine, First, LastInstruction, } impl Default for Config { /// Initializes a new Config object with default parameters #[allow(dead_code)] fn default() -> Config { Config { pid: None, python_program: None, filename: None, format: None, command: String::from("top"), blocking: LockingStrategy::Lock, show_line_numbers: false, sampling_rate: 100, duration: RecordDuration::Unlimited, native: false, gil_only: false, include_idle: false, include_thread_ids: false, hide_progress: false, capture_output: true, dump_json: false, dump_locals: 0, subprocesses: false, full_filenames: false, lineno: LineNo::LastInstruction, refresh_seconds: 1.0, core_filename: None, } } } impl Config { /// Uses clap to set config options from commandline arguments pub fn from_commandline() -> Config { let args: Vec = std::env::args().collect(); Config::from_args(&args).unwrap_or_else(|e| e.exit()) } pub fn from_args(args: &[String]) -> clap::Result { // pid/native/nonblocking/rate/python_program/subprocesses/full_filenames arguments can be // used across various subcommand - define once here let pid = Arg::new("pid") .short('p') .long("pid") .value_name("pid") .help("PID of a running python program to spy on, in decimal or hex") .takes_value(true); let mut native = Arg::new("native") .short('n') .long("native") .help("Collect stack traces from native extensions written in Cython, C or C++"); // Only show `--native` on platforms where it's supported if !cfg!(feature = "unwind") { native = native.hide(true); } #[cfg(not(target_os="freebsd"))] let nonblocking = Arg::new("nonblocking") .long("nonblocking") .help("Don't pause the python process when collecting samples. Setting this option will reduce \ the performance impact of sampling, but may lead to inaccurate results"); let rate = Arg::new("rate") .short('r') .long("rate") .value_name("rate") .help("The number of samples to collect per second") .default_value("100") .takes_value(true); let subprocesses = Arg::new("subprocesses") .short('s') .long("subprocesses") .help("Profile subprocesses of the original process"); let full_filenames = Arg::new("full_filenames").long("full-filenames").help( "Show full Python filenames, instead of shortening to show only the package part", ); let program = Arg::new("python_program") .help("commandline of a python program to run") .multiple_values(true); let idle = Arg::new("idle") .short('i') .long("idle") .help("Include stack traces for idle threads"); let gil = Arg::new("gil") .short('g') .long("gil") .help("Only include traces that are holding on to the GIL"); let top_delay = Arg::new("delay") .long("delay") .value_name("seconds") .help("Delay between 'top' refreshes.") .default_value("1.0") .value_parser(clap::value_parser!(f64)) .takes_value(true); let record = Command::new("record") .about("Records stack trace information to a flamegraph, speedscope or raw file") .arg(program.clone()) .arg(pid.clone().required_unless_present("python_program")) .arg(full_filenames.clone()) .arg( Arg::new("output") .short('o') .long("output") .value_name("filename") .help("Output filename") .takes_value(true) .required(false), ) .arg( Arg::new("format") .short('f') .long("format") .value_name("format") .help("Output file format") .takes_value(true) .possible_values(FileFormat::possible_values()) .ignore_case(true) .default_value("flamegraph"), ) .arg( Arg::new("duration") .short('d') .long("duration") .value_name("duration") .help("The number of seconds to sample for") .default_value("unlimited") .takes_value(true), ) .arg(rate.clone()) .arg(subprocesses.clone()) .arg(Arg::new("function").short('F').long("function").help( "Aggregate samples by function's first line number, instead of current line number", )) .arg( Arg::new("nolineno") .long("nolineno") .help("Do not show line numbers"), ) .arg( Arg::new("threads") .short('t') .long("threads") .help("Show thread ids in the output"), ) .arg(gil.clone()) .arg(idle.clone()) .arg( Arg::new("capture") .long("capture") .hide(true) .help("Captures output from child process"), ) .arg( Arg::new("hideprogress") .long("hideprogress") .hide(true) .help("Hides progress bar (useful for showing error output on record)"), ); let top = Command::new("top") .about("Displays a top like view of functions consuming CPU") .arg(program.clone()) .arg(pid.clone().required_unless_present("python_program")) .arg(rate.clone()) .arg(subprocesses.clone()) .arg(full_filenames.clone()) .arg(gil.clone()) .arg(idle.clone()) .arg(top_delay.clone()); #[cfg(target_os = "linux")] let dump_pid = pid.clone().required_unless_present("core"); #[cfg(not(target_os = "linux"))] let dump_pid = pid.clone().required(true); let dump = Command::new("dump") .about("Dumps stack traces for a target program to stdout") .arg(dump_pid); #[cfg(target_os = "linux")] let dump = dump.arg( Arg::new("core") .short('c') .long("core") .help("Filename of coredump to display python stack traces from") .value_name("core") .takes_value(true), ); let dump = dump.arg(full_filenames.clone()) .arg(Arg::new("locals") .short('l') .long("locals") .multiple_occurrences(true) .help("Show local variables for each frame. Passing multiple times (-ll) increases verbosity")) .arg(Arg::new("json") .short('j') .long("json") .help("Format output as JSON")) .arg(subprocesses.clone()); let completions = Command::new("completions") .about("Generate shell completions") .hide(true) .arg( Arg::new("shell") .value_parser(value_parser!(clap_complete::Shell)) .help("Shell type"), ); let record = record.arg(native.clone()); let top = top.arg(native.clone()); let dump = dump.arg(native.clone()); // Nonblocking isn't an option for freebsd, remove #[cfg(not(target_os = "freebsd"))] let record = record.arg(nonblocking.clone()); #[cfg(not(target_os = "freebsd"))] let top = top.arg(nonblocking.clone()); #[cfg(not(target_os = "freebsd"))] let dump = dump.arg(nonblocking.clone()); let mut app = Command::new(crate_name!()) .version(crate_version!()) .about(crate_description!()) .subcommand_required(true) .infer_subcommands(true) .arg_required_else_help(true) .global_setting(clap::AppSettings::DeriveDisplayOrder) .subcommand(record) .subcommand(top) .subcommand(dump) .subcommand(completions); let matches = app.clone().try_get_matches_from(args)?; info!("Command line args: {:?}", matches); let mut config = Config::default(); let (subcommand, matches) = matches.subcommand().unwrap(); // Check if `--native` was used on an unsupported platform if !cfg!(feature = "unwind") && matches.contains_id("native") { eprintln!( "Collecting stack traces from native extensions (`--native`) is not supported on your platform." ); std::process::exit(1); } match subcommand { "record" => { config.sampling_rate = matches.value_of_t("rate")?; config.duration = match matches.value_of("duration") { Some("unlimited") | None => RecordDuration::Unlimited, Some(seconds) => { RecordDuration::Seconds(seconds.parse().expect("invalid duration")) } }; config.format = Some(matches.value_of_t("format")?); config.filename = matches.value_of("output").map(|f| f.to_owned()); config.show_line_numbers = matches.occurrences_of("nolineno") == 0; config.lineno = if matches.occurrences_of("nolineno") > 0 { LineNo::NoLine } else if matches.occurrences_of("function") > 0 { LineNo::First } else { LineNo::LastInstruction }; config.include_thread_ids = matches.occurrences_of("threads") > 0; if matches.occurrences_of("nolineno") > 0 && matches.occurrences_of("function") > 0 { eprintln!("--function & --nolinenos can't be used together"); std::process::exit(1); } config.hide_progress = matches.occurrences_of("hideprogress") > 0; } "top" => { config.sampling_rate = matches.value_of_t("rate")?; config.refresh_seconds = *matches.get_one::("delay").unwrap(); } "dump" => { config.dump_json = matches.occurrences_of("json") > 0; config.dump_locals = matches.occurrences_of("locals"); #[cfg(target_os = "linux")] { config.core_filename = matches.value_of("core").map(|f| f.to_owned()); } } "completions" => { let shell = matches.get_one::("shell").unwrap(); let app_name = app.get_name().to_string(); clap_complete::generate(*shell, &mut app, app_name, &mut std::io::stdout()); std::process::exit(0); } _ => {} } match subcommand { "record" | "top" => { config.python_program = matches .values_of("python_program") .map(|vals| vals.map(|v| v.to_owned()).collect()); config.gil_only = matches.occurrences_of("gil") > 0; config.include_idle = matches.occurrences_of("idle") > 0; } _ => {} } config.subprocesses = matches.occurrences_of("subprocesses") > 0; config.command = subcommand.to_owned(); // options that can be shared between subcommands config.pid = matches.value_of("pid").map(|p| { // allow pid to be specified as a hexadecimal value match p.to_lowercase().strip_prefix("0x") { Some(prefix) => Pid::from_str_radix(prefix, 16).expect("invalid pid"), None => p.parse().expect("invalid pid"), } }); config.full_filenames = matches.occurrences_of("full_filenames") > 0; if cfg!(feature = "unwind") { config.native = matches.occurrences_of("native") > 0; } config.capture_output = config.command != "record" || matches.occurrences_of("capture") > 0; if !config.capture_output { config.hide_progress = true; } if matches.occurrences_of("nonblocking") > 0 { // disable native profiling if invalidly asked for if config.native { eprintln!("Can't get native stack traces with the --nonblocking option."); std::process::exit(1); } config.blocking = LockingStrategy::NonBlocking; } #[cfg(windows)] { if config.native && config.subprocesses { // the native extension profiling code relies on dbghelp library, which doesn't // seem to work when connecting to multiple processes. disallow eprintln!( "Can't get native stack traces with the ---subprocesses option on windows." ); std::process::exit(1); } } #[cfg(target_os = "freebsd")] { if config.pid.is_some() { if std::env::var("PYSPY_ALLOW_FREEBSD_ATTACH").is_err() { eprintln!("On FreeBSD, running py-spy can cause an exception in the profiled process if the process \ is calling 'socket.connect'."); eprintln!("While this is fixed in recent versions of python, you need to acknowledge the risk here by \ setting an environment variable PYSPY_ALLOW_FREEBSD_ATTACH to run this command."); eprintln!( "\nSee https://github.com/benfred/py-spy/issues/147 for more information" ); std::process::exit(-1); } } } Ok(config) } } #[cfg(test)] mod tests { use super::*; fn get_config(cmd: &str) -> clap::Result { #[cfg(target_os = "freebsd")] std::env::set_var("PYSPY_ALLOW_FREEBSD_ATTACH", "1"); let args: Vec = cmd.split_whitespace().map(|x| x.to_owned()).collect(); Config::from_args(&args) } #[test] fn test_parse_record_args() { // basic use case let config = get_config("py-spy record --pid 1234 --output foo").unwrap(); assert_eq!(config.pid, Some(1234)); assert_eq!(config.filename, Some(String::from("foo"))); assert_eq!(config.format, Some(FileFormat::flamegraph)); assert_eq!(config.command, String::from("record")); // same command using short versions of everything let short_config = get_config("py-spy r -p 1234 -o foo").unwrap(); assert_eq!(config, short_config); // missing the --pid argument should fail assert_eq!( get_config("py-spy record -o foo").unwrap_err().kind, clap::ErrorKind::MissingRequiredArgument ); // but should work when passed a python program let program_config = get_config("py-spy r -o foo -- python test.py").unwrap(); assert_eq!( program_config.python_program, Some(vec![String::from("python"), String::from("test.py")]) ); assert_eq!(program_config.pid, None); // passing an invalid file format should fail assert_eq!( get_config("py-spy r -p 1234 -o foo -f unknown") .unwrap_err() .kind, clap::ErrorKind::InvalidValue ); // test out overriding these params by setting flags assert_eq!(config.include_idle, false); assert_eq!(config.gil_only, false); assert_eq!(config.include_thread_ids, false); let config_flags = get_config("py-spy r -p 1234 -o foo --idle --gil --threads").unwrap(); assert_eq!(config_flags.include_idle, true); assert_eq!(config_flags.gil_only, true); assert_eq!(config_flags.include_thread_ids, true); } #[test] fn test_parse_dump_args() { // basic use case let config = get_config("py-spy dump --pid 1234").unwrap(); assert_eq!(config.pid, Some(1234)); assert_eq!(config.command, String::from("dump")); // short version let short_config = get_config("py-spy d -p 1234").unwrap(); assert_eq!(config, short_config); // missing the --pid argument should fail assert_eq!( get_config("py-spy dump").unwrap_err().kind, clap::ErrorKind::MissingRequiredArgument ); } #[test] fn test_parse_top_args() { // basic use case let config = get_config("py-spy top --pid 1234").unwrap(); assert_eq!(config.pid, Some(1234)); assert_eq!(config.command, String::from("top")); // short version let short_config = get_config("py-spy t -p 1234").unwrap(); assert_eq!(config, short_config); } #[test] fn test_parse_args() { assert_eq!( get_config("py-spy dude").unwrap_err().kind, clap::ErrorKind::UnrecognizedSubcommand ); } } ================================================ FILE: src/console_viewer.rs ================================================ use std::collections::HashMap; use std::io; use std::io::{BufReader, Read, Write}; use std::sync::{atomic, Arc, Mutex}; use std::thread; use std::vec::Vec; use anyhow::Error; use console::{style, Term}; use crate::config::Config; use crate::stack_trace::{Frame, StackTrace}; use crate::version::Version; pub struct ConsoleViewer { #[allow(dead_code)] console_config: os_impl::ConsoleConfig, version: Option, command: String, sampling_rate: f64, running: Arc, options: Arc>, stats: Stats, subprocesses: bool, config: Config, } impl ConsoleViewer { pub fn new( show_linenumbers: bool, python_command: &str, version: &Option, config: &Config, ) -> io::Result { let sampling_rate = 1.0 / (config.sampling_rate as f64); let running = Arc::new(atomic::AtomicBool::new(true)); let options = Arc::new(Mutex::new(Options::new(show_linenumbers))); // listen for keyboard events in a separate thread to avoid blocking here let input_running = running.clone(); let input_options = options.clone(); thread::spawn(move || { let stdin = std::io::stdin(); let mut buf_reader = BufReader::new(stdin); let mut buffer = [0u8; 1]; while input_running.load(atomic::Ordering::Relaxed) { // TODO: there isn't a non-blocking version of stdin, so this will capture the // next keystroke after the ConsoleViewer object has been destroyed =( if buf_reader.read_exact(&mut buffer).is_ok() { let mut options = input_options.lock().unwrap(); options.dirty = true; let previous_usage = options.usage; match buffer[0] as char { 'R' | 'r' => options.reset = true, 'L' | 'l' => options.show_linenumbers = !options.show_linenumbers, 'X' | 'x' => options.usage = false, '?' => options.usage = true, '1' => options.sort_column = 1, '2' => options.sort_column = 2, '3' => options.sort_column = 3, '4' => options.sort_column = 4, _ => {} } options.reset_style = previous_usage != options.usage; } } }); Ok(ConsoleViewer { console_config: os_impl::ConsoleConfig::new()?, version: version.clone(), command: python_command.to_owned(), running, options, sampling_rate, subprocesses: config.subprocesses, stats: Stats::new(), config: config.clone(), }) } pub fn increment(&mut self, traces: &[StackTrace]) -> Result<(), Error> { self.maybe_reset(); self.stats.threads = 0; self.stats.processes = 0; let mut last_pid = None; for trace in traces { self.stats.threads += 1; if last_pid != Some(trace.pid) { self.stats.processes += 1; last_pid = Some(trace.pid); } if !(self.config.include_idle || trace.active) { continue; } if self.config.gil_only && !trace.owns_gil { continue; } if trace.owns_gil { self.stats.gil += 1 } if trace.active { self.stats.active += 1 } update_function_statistics(&mut self.stats.line_counts, trace, |frame| { let filename = match &frame.short_filename { Some(f) => f, None => &frame.filename, }; if frame.line != 0 { format!("{} ({}:{})", frame.name, filename, frame.line) } else { format!("{} ({})", frame.name, filename) } }); update_function_statistics(&mut self.stats.function_counts, trace, |frame| { let filename = match &frame.short_filename { Some(f) => f, None => &frame.filename, }; format!("{} ({})", frame.name, filename) }); } self.increment_common()?; Ok(()) } pub fn display(&self) -> std::io::Result<()> { // Get the top aggregate function calls (either by line or by function as ) let mut options = self.options.lock().unwrap(); options.dirty = false; let counts = if options.show_linenumbers { &self.stats.line_counts } else { &self.stats.function_counts }; let mut counts: Vec<(&FunctionStatistics, &str)> = counts.iter().map(|(x, y)| (y, x.as_ref())).collect(); // TODO: subsort ? match options.sort_column { 1 => counts.sort_unstable_by(|a, b| b.0.current_own.cmp(&a.0.current_own)), 2 => counts.sort_unstable_by(|a, b| b.0.current_total.cmp(&a.0.current_total)), 3 => counts.sort_unstable_by(|a, b| b.0.overall_own.cmp(&a.0.overall_own)), 4 => counts.sort_unstable_by(|a, b| b.0.overall_total.cmp(&a.0.overall_total)), _ => panic!("unknown sort column. this really shouldn't happen"), } let term = Term::stdout(); let (height, width) = term.size(); let width = width as usize; // this macro acts like println but also clears the rest of the line if there is already text // written there. This is to avoid flickering on redraw, and lets us update just by moving the cursor // position to the top left. macro_rules! out { () => (term.clear_line()?; term.write_line("")?); ($($arg:tt)*) => { term.clear_line()?; term.write_line(&format!($($arg)*))?; } } if options.reset_style { #[cfg(windows)] self.console_config.reset_styles()?; options.reset_style = false; } self.console_config.reset_cursor()?; let mut header_lines = if options.usage { 18 } else { 8 }; if let Some(delay) = self.stats.last_delay { let late_rate = self.stats.late_samples as f64 / self.stats.overall_samples as f64; if late_rate > 0.10 && delay > std::time::Duration::from_secs(1) { let msg = format!("{delay:.2?} behind in sampling, results may be inaccurate. Try reducing the sampling rate."); out!("{}", style(msg).red()); header_lines += 1; } } if self.subprocesses { out!( "Collecting samples from '{}' and subprocesses", style(&self.command).green() ); } else { out!( "Collecting samples from '{}' (python v{})", style(&self.command).green(), self.version.as_ref().unwrap() ); } let error_rate = self.stats.errors as f64 / self.stats.overall_samples as f64; if error_rate >= 0.01 && self.stats.overall_samples > 100 { let error_string = self.stats.last_error.as_ref().unwrap(); out!( "Total Samples {}, Error Rate {:.2}% ({})", style(self.stats.overall_samples).bold(), style(error_rate * 100.0).bold().red(), style(error_string).bold() ); } else { out!("Total Samples {}", style(self.stats.overall_samples).bold()); } out!( "GIL: {:.2}%, Active: {:>.2}%, Threads: {}{}", style(100.0 * self.stats.gil as f64 / self.stats.current_samples as f64).bold(), style(100.0 * self.stats.active as f64 / self.stats.current_samples as f64).bold(), style(self.stats.threads).bold(), if self.subprocesses { format!(", Processes {}", style(self.stats.processes).bold()) } else { "".to_owned() } ); out!(); // Build up the header for the table let mut percent_own_header = style("%Own ").reverse(); let mut percent_total_header = style("%Total").reverse(); let mut time_own_header = style("OwnTime").reverse(); let mut time_total_header = style("TotalTime").reverse(); match options.sort_column { 1 => percent_own_header = percent_own_header.bold(), 2 => percent_total_header = percent_total_header.bold(), 3 => time_own_header = time_own_header.bold(), 4 => time_total_header = time_total_header.bold(), _ => {} } let function_header = if options.show_linenumbers { style(" Function (filename:line)").reverse() } else { style(" Function (filename)").reverse() }; // If we aren't at least 50 characters wide, lets use two lines per entry // Otherwise, truncate the filename so that it doesn't wrap around to the next line let header_lines = if width > 50 { header_lines } else { header_lines + height as usize / 2 }; let max_function_width = if width > 50 { width - 35 } else { width }; out!( "{:>7}{:>8}{:>9}{:>11}{:width$}", percent_own_header, percent_total_header, time_own_header, time_total_header, function_header, width = max_function_width ); let mut written = 0; for (samples, label) in counts.iter().take(height as usize - header_lines) { out!( "{:>6.2}% {:>6.2}% {:>7}s {:>8}s {:.width$}", 100.0 * samples.current_own as f64 / (self.stats.current_samples as f64), 100.0 * samples.current_total as f64 / (self.stats.current_samples as f64), display_time(samples.overall_own as f64 * self.sampling_rate), display_time(samples.overall_total as f64 * self.sampling_rate), label, width = max_function_width - 2 ); written += 1; } for _ in written..height as usize - header_lines { out!(); } out!(); if options.usage { out!( "{:width$}", style(" Keyboard Shortcuts ").reverse(), width = width ); out!(); out!("{:^12}{:<}", style("key").green(), style("action").green()); out!( "{:^12}{:<}", "1", "Sort by %Own (% of time currently spent in the function)" ); out!( "{:^12}{:<}", "2", "Sort by %Total (% of time currently in the function and its children)" ); out!( "{:^12}{:<}", "3", "Sort by OwnTime (Overall time spent in the function)" ); out!( "{:^12}{:<}", "4", "Sort by TotalTime (Overall time spent in the function and its children)" ); out!( "{:^12}{:<}", "L,l", "Toggle between aggregating by line number or by function" ); out!("{:^12}{:<}", "R,r", "Reset statistics"); out!("{:^12}{:<}", "X,x", "Exit this help screen"); out!(); //println!("{:^12}{:<}", "Control-C", "Quit py-spy"); } else { out!( "Press {} to quit, or {} for help.", style("Control-C").bold().reverse(), style("?").bold().reverse() ); } std::io::stdout().flush()?; Ok(()) } pub fn increment_error(&mut self, err: &Error) -> Result<(), Error> { self.maybe_reset(); self.stats.errors += 1; self.stats.last_error = Some(format!("{err}")); self.increment_common() } pub fn increment_late_sample(&mut self, delay: std::time::Duration) { self.stats.late_samples += 1; self.stats.last_delay = Some(delay); } pub fn should_refresh(&self) -> bool { // update faster if we only have a few samples, or if we changed options match self.stats.overall_samples { 10 | 100 | 500 => true, _ => { self.options.lock().unwrap().dirty || self.stats.elapsed >= self.config.refresh_seconds } } } // shared code between increment and increment_error fn increment_common(&mut self) -> Result<(), Error> { self.stats.current_samples += 1; self.stats.overall_samples += 1; self.stats.elapsed += self.sampling_rate; if self.should_refresh() { self.display()?; self.stats.reset_current(); } Ok(()) } fn maybe_reset(&mut self) { let mut options = self.options.lock().unwrap(); if options.reset { self.stats = Stats::new(); options.reset = false; } } } impl Drop for ConsoleViewer { fn drop(&mut self) { self.running.store(false, atomic::Ordering::Relaxed); } } #[derive(Eq, PartialEq, Ord, PartialOrd, Debug)] struct FunctionStatistics { current_own: u64, current_total: u64, overall_own: u64, overall_total: u64, } fn update_function_statistics( counts: &mut HashMap, trace: &StackTrace, key_func: K, ) where K: Fn(&Frame) -> String, { // we need to deduplicate (so we don't overcount cumulative stats with recursive function calls) let mut current = HashMap::new(); for (i, frame) in trace.frames.iter().enumerate() { let key = key_func(frame); current.entry(key).or_insert(i); } for (key, order) in current { let entry = counts.entry(key).or_insert_with(|| FunctionStatistics { current_own: 0, current_total: 0, overall_own: 0, overall_total: 0, }); entry.current_total += 1; entry.overall_total += 1; if order == 0 { entry.current_own += 1; entry.overall_own += 1; } } } struct Options { dirty: bool, usage: bool, reset_style: bool, sort_column: i32, show_linenumbers: bool, reset: bool, } struct Stats { current_samples: u64, overall_samples: u64, elapsed: f64, errors: u64, late_samples: u64, threads: u64, processes: u64, active: u64, gil: u64, function_counts: HashMap, line_counts: HashMap, last_error: Option, last_delay: Option, } impl Options { fn new(show_linenumbers: bool) -> Options { Options { dirty: false, usage: false, reset: false, sort_column: 3, show_linenumbers, reset_style: false, } } } impl Stats { fn new() -> Stats { Stats { current_samples: 0, overall_samples: 0, elapsed: 0., errors: 0, late_samples: 0, threads: 0, processes: 0, gil: 0, active: 0, line_counts: HashMap::new(), function_counts: HashMap::new(), last_error: None, last_delay: None, } } pub fn reset_current(&mut self) { // reset current statistics for val in self.line_counts.values_mut() { val.current_total = 0; val.current_own = 0; } for val in self.function_counts.values_mut() { val.current_total = 0; val.current_own = 0; } self.gil = 0; self.active = 0; self.current_samples = 0; self.elapsed = 0.; } } // helper function for formatting time values (hide decimals for larger values) fn display_time(val: f64) -> String { if val > 1000.0 { format!("{val:.0}") } else if val >= 100.0 { format!("{val:.1}") } else if val >= 1.0 { format!("{val:.2}") } else { format!("{val:.3}") } } /* This rest of this code is OS specific functions for setting up keyboard input appropriately (don't wait for a newline, and disable echo), and clearing the terminal window. This is all relatively low level, but there doesn't seem to be any great libraries out there for doing this: https://github.com/redox-os/termion doesn't work on windows https://github.com/gyscos/Cursive requires ncurses installed https://github.com/ihalila/pancurses requires ncurses installed */ // operating system specific details on setting up console to receive single characters without displaying #[cfg(unix)] mod os_impl { use super::*; use termios::{tcsetattr, Termios, ECHO, ICANON, TCSANOW}; pub struct ConsoleConfig { termios: Termios, stdin: i32, } impl ConsoleConfig { pub fn new() -> io::Result { // Set up stdin to not echo the input, and not wait for a return let stdin = 0; let termios = Termios::from_fd(stdin)?; { let mut termios = termios; termios.c_lflag &= !(ICANON | ECHO); tcsetattr(stdin, TCSANOW, &termios)?; } // flush current screen so that when we clear, we don't overwrite history let height = Term::stdout().size().0; for _ in 0..=height { println!(); } Ok(ConsoleConfig { termios, stdin }) } pub fn reset_cursor(&self) -> io::Result<()> { // reset cursor to top left position https://en.wikipedia.org/wiki/ANSI_escape_code print!("\x1B[H"); Ok(()) } } impl Drop for ConsoleConfig { fn drop(&mut self) { tcsetattr(self.stdin, TCSANOW, &self.termios).unwrap(); } } } // operating system specific details on setting up console to receive single characters #[cfg(windows)] mod os_impl { use super::*; use winapi::shared::minwindef::DWORD; use winapi::um::consoleapi::{GetConsoleMode, SetConsoleMode}; use winapi::um::handleapi::INVALID_HANDLE_VALUE; use winapi::um::processenv::GetStdHandle; use winapi::um::winbase::{STD_INPUT_HANDLE, STD_OUTPUT_HANDLE}; use winapi::um::wincon::{ FillConsoleOutputAttribute, GetConsoleScreenBufferInfo, SetConsoleCursorPosition, CONSOLE_SCREEN_BUFFER_INFO, COORD, ENABLE_ECHO_INPUT, ENABLE_LINE_INPUT, }; use winapi::um::winnt::HANDLE; pub struct ConsoleConfig { stdin: HANDLE, mode: DWORD, top_left: COORD, } impl ConsoleConfig { pub fn new() -> io::Result { unsafe { let stdin = GetStdHandle(STD_INPUT_HANDLE); if stdin == INVALID_HANDLE_VALUE { return Err(io::Error::last_os_error()); } let mut mode: DWORD = 0; if GetConsoleMode(stdin, &mut mode) == 0 { return Err(io::Error::last_os_error()); } if SetConsoleMode(stdin, mode & !(ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT)) == 0 { return Err(io::Error::last_os_error()); } let stdout = GetStdHandle(STD_OUTPUT_HANDLE); // flush current screen so that when we clear, we don't overwrite history let height = Term::stdout().size().0 as i16; for _ in 0..height + 1 { println!(); } // Get information about the current console (size/background etc) let mut csbi = CONSOLE_SCREEN_BUFFER_INFO::default(); if GetConsoleScreenBufferInfo(stdout, &mut csbi) == 0 { return Err(io::Error::last_os_error()); } // Figure out a consistent spot in the terminal buffer to write output to let mut top_left = csbi.dwCursorPosition; top_left.X = 0; top_left.Y = if top_left.Y > height { top_left.Y - height } else { 0 }; Ok(ConsoleConfig { stdin, mode, top_left, }) } } pub fn reset_cursor(&self) -> io::Result<()> { unsafe { // Set cursor to top-left using the win32 api. // (this works better than moving the cursor using ANSI escape codes in the // case when the user is scrolling the terminal window) let stdout = GetStdHandle(STD_OUTPUT_HANDLE); if SetConsoleCursorPosition(stdout, self.top_left) == 0 { return Err(io::Error::last_os_error()); } Ok(()) } } pub fn reset_styles(&self) -> io::Result<()> { unsafe { let stdout = GetStdHandle(STD_OUTPUT_HANDLE); let mut csbi = CONSOLE_SCREEN_BUFFER_INFO::default(); if GetConsoleScreenBufferInfo(stdout, &mut csbi) == 0 { return Err(io::Error::last_os_error()); } let mut written: DWORD = 0; let console_size = ((1 + csbi.srWindow.Bottom - csbi.srWindow.Top) * (csbi.srWindow.Right - csbi.srWindow.Left)) as DWORD; if FillConsoleOutputAttribute( stdout, csbi.wAttributes, console_size, self.top_left, &mut written, ) == 0 { return Err(io::Error::last_os_error()); } Ok(()) } } } impl Drop for ConsoleConfig { fn drop(&mut self) { unsafe { SetConsoleMode(self.stdin, self.mode); } } } } ================================================ FILE: src/coredump.rs ================================================ use std::collections::HashMap; use std::ffi::OsStr; use std::fs::File; use std::io::Read; use std::os::unix::ffi::OsStrExt; use std::path::Path; use std::path::PathBuf; use anyhow::{Context, Error, Result}; use console::style; use log::info; use remoteprocess::ProcessMemory; use crate::binary_parser::{parse_binary, BinaryInfo}; use crate::config::Config; use crate::dump::print_trace; use crate::python_bindings::{ v2_7_15, v3_10_0, v3_11_0, v3_12_0, v3_13_0, v3_3_7, v3_5_5, v3_6_6, v3_7_0, v3_8_0, v3_9_5, }; use crate::python_data_access::format_variable; use crate::python_interpreters::InterpreterState; use crate::python_process_info::{ get_interpreter_address, get_python_version, get_threadstate_address, is_python_lib, ContainsAddr, PythonProcessInfo, }; use crate::python_threading::thread_names_from_interpreter; use crate::stack_trace::{get_stack_traces, StackTrace}; use crate::version::Version; #[derive(Debug, Clone)] pub struct CoreMapRange { pub pathname: Option, pub segment: goblin::elf::ProgramHeader, } // Defines accessors to match those in proc_maps. However, can't use the // proc_maps trait since is private impl CoreMapRange { pub fn size(&self) -> usize { self.segment.p_memsz as usize } pub fn start(&self) -> usize { self.segment.p_vaddr as usize } pub fn filename(&self) -> Option<&Path> { self.pathname.as_deref() } pub fn is_exec(&self) -> bool { self.segment.is_executable() } pub fn is_write(&self) -> bool { self.segment.is_write() } pub fn is_read(&self) -> bool { self.segment.is_read() } } impl ContainsAddr for Vec { fn contains_addr(&self, addr: usize) -> bool { self.iter() .any(|map| (addr >= map.start()) && (addr < (map.start() + map.size()))) } } pub struct CoreDump { filename: PathBuf, contents: Vec, maps: Vec, psinfo: Option, status: Vec, } impl CoreDump { pub fn new>(filename: P) -> Result { let filename = filename.as_ref(); let mut file = File::open(filename)?; let mut contents = Vec::new(); file.read_to_end(&mut contents)?; let elf = goblin::elf::Elf::parse(&contents)?; let notes = elf .iter_note_headers(&contents) .ok_or_else(|| format_err!("no note segment found"))?; let mut filenames = HashMap::new(); let mut psinfo = None; let mut status = Vec::new(); for note in notes.flatten() { if note.n_type == goblin::elf::note::NT_PRPSINFO { psinfo = Some(unsafe { std::ptr::read_unaligned(note.desc.as_ptr() as *const elfcore::elf_prpsinfo) }); } else if note.n_type == goblin::elf::note::NT_PRSTATUS { let thread_status: elfcore::elf_prstatus = unsafe { std::ptr::read_unaligned(note.desc.as_ptr() as *const elfcore::elf_prstatus) }; status.push(thread_status); } else if note.n_type == goblin::elf::note::NT_FILE { let data = note.desc; let ptrs = data.as_ptr() as *const usize; let count = unsafe { std::ptr::read_unaligned(ptrs) }; let _page_size = unsafe { std::ptr::read_unaligned(ptrs.offset(1)) }; let string_table = &data[(std::mem::size_of::() * (2 + count * 3))..]; for (i, filename) in string_table.split(|chr| *chr == 0).enumerate() { if i < count { let i = i as isize; let start = unsafe { std::ptr::read_unaligned(ptrs.offset(i * 3 + 2)) }; let _end = unsafe { std::ptr::read_unaligned(ptrs.offset(i * 3 + 3)) }; let _page_offset = unsafe { std::ptr::read_unaligned(ptrs.offset(i * 3 + 4)) }; let pathname = Path::new(&OsStr::from_bytes(filename)).to_path_buf(); filenames.insert(start, pathname); } } } } let mut maps = Vec::new(); for ph in elf.program_headers { if ph.p_type == goblin::elf::program_header::PT_LOAD { let pathname = filenames.get(&(ph.p_vaddr as _)); let map = CoreMapRange { pathname: pathname.cloned(), segment: ph, }; info!( "map: {:016x}-{:016x} {}{}{} {}", map.start(), map.start() + map.size(), if map.is_read() { 'r' } else { '-' }, if map.is_write() { 'w' } else { '-' }, if map.is_exec() { 'x' } else { '-' }, map.filename() .unwrap_or(&std::path::PathBuf::from("")) .display() ); maps.push(map); } } Ok(CoreDump { filename: filename.to_owned(), contents, maps, psinfo, status, }) } } impl ProcessMemory for CoreDump { fn read(&self, addr: usize, buf: &mut [u8]) -> Result<(), remoteprocess::Error> { let start = addr as u64; let _end = (addr + buf.len()) as u64; for map in &self.maps { // TODO: one issue here is the bss addr spans multiple mmap segments - so checking the 'end' // here means we skip it. Instead we're just checking if the start address exists in // the segment let ph = &map.segment; if start >= ph.p_vaddr && start <= (ph.p_vaddr + ph.p_memsz) { let offset = (start - ph.p_vaddr + ph.p_offset) as usize; buf.copy_from_slice(&self.contents[offset..(offset + buf.len())]); return Ok(()); } } let io_error = std::io::Error::from_raw_os_error(libc::EFAULT); Err(remoteprocess::Error::IOError(io_error)) } } pub struct PythonCoreDump { core: CoreDump, version: Version, interpreter_address: usize, threadstate_address: usize, } impl PythonCoreDump { pub fn new>(filename: P) -> Result { let core = CoreDump::new(filename)?; let maps = &core.maps; // Get the python binary from the maps, and parse it let (python_filename, python_binary) = { let map = maps .iter() .find(|m| m.filename().is_some() & m.is_exec()) .ok_or_else(|| format_err!("Failed to get binary from coredump"))?; let python_filename = map.filename().unwrap(); let python_binary = parse_binary(python_filename, map.start() as _, map.size() as _); info!("Found python binary @ {}", python_filename.display()); (python_filename.to_owned(), python_binary) }; // get the libpython binary (if any) from maps let libpython_binary = { let libmap = maps.iter().find(|m| { if let Some(pathname) = m.filename() { if let Some(pathname) = pathname.to_str() { return is_python_lib(pathname) && m.is_exec(); } } false }); let mut libpython_binary: Option = None; if let Some(libpython) = libmap { if let Some(filename) = &libpython.filename() { info!("Found libpython binary @ {}", filename.display()); let parsed = parse_binary(filename, libpython.start() as u64, libpython.size() as u64)?; libpython_binary = Some(parsed); } } libpython_binary }; // If we have a libpython binary - we can tolerate failures on parsing the main python binary. let python_binary = match libpython_binary { None => Some(python_binary.context("Failed to parse python binary")?), _ => python_binary.ok(), }; let python_info = PythonProcessInfo { python_binary, libpython_binary, maps: Box::new(core.maps.clone()), python_filename, dockerized: false, }; let version = get_python_version(&python_info, &core).context("failed to get python version")?; info!("Got python version {}", version); let interpreter_address = get_interpreter_address(&python_info, &core, &version)?; info!("Found interpreter at 0x{:016x}", interpreter_address); // lets us figure out which thread has the GIL let config = Config::default(); let threadstate_address = get_threadstate_address(interpreter_address, &python_info, &core, &version, &config)?; info!("found threadstate at 0x{:016x}", threadstate_address); Ok(PythonCoreDump { core, version, interpreter_address, threadstate_address, }) } pub fn get_stack(&self, config: &Config) -> Result, Error> { if config.native { return Err(format_err!( "Native unwinding isn't yet supported with coredumps" )); } if config.subprocesses { return Err(format_err!( "Subprocesses can't be used for getting stacktraces from coredumps" )); } // different versions have different layouts, check as appropriate match self.version { Version { major: 2, minor: 3..=7, .. } => self._get_stack::(config), Version { major: 3, minor: 3, .. } => self._get_stack::(config), Version { major: 3, minor: 4..=5, .. } => self._get_stack::(config), Version { major: 3, minor: 6, .. } => self._get_stack::(config), Version { major: 3, minor: 7, .. } => self._get_stack::(config), Version { major: 3, minor: 8, .. } => self._get_stack::(config), Version { major: 3, minor: 9, .. } => self._get_stack::(config), Version { major: 3, minor: 10, .. } => self._get_stack::(config), Version { major: 3, minor: 11, .. } => self._get_stack::(config), Version { major: 3, minor: 12, .. } => self._get_stack::(config), Version { major: 3, minor: 13, .. } => self._get_stack::(config), _ => Err(format_err!( "Unsupported version of Python: {}", self.version )), } } fn _get_stack(&self, config: &Config) -> Result, Error> { let mut traces = get_stack_traces::( self.interpreter_address, &self.core, self.threadstate_address, Some(config), )?; let thread_names = thread_names_from_interpreter::( self.interpreter_address, &self.core, &self.version, ) .ok(); for trace in &mut traces { if let Some(ref thread_names) = thread_names { trace.thread_name = thread_names.get(&trace.thread_id).cloned(); } for frame in &mut trace.frames { if let Some(locals) = frame.locals.as_mut() { let max_length = (128 * config.dump_locals) as isize; for local in locals { let repr = format_variable::( &self.core, &self.version, local.addr, max_length, ); local.repr = Some(repr.unwrap_or_else(|_| "?".to_owned())); } } } } Ok(traces) } pub fn print_traces(&self, traces: &Vec, config: &Config) -> Result<(), Error> { if config.dump_json { println!("{}", serde_json::to_string_pretty(&traces)?); return Ok(()); } if let Some(status) = self.core.status.first() { println!( "Signal {}: {}", style(status.pr_cursig).bold().yellow(), self.core.filename.display() ); } if let Some(psinfo) = self.core.psinfo { println!( "Process {}: {}", style(psinfo.pr_pid).bold().yellow(), OsStr::from_bytes(&psinfo.pr_psargs).to_string_lossy() ); } println!("Python v{}", style(&self.version).bold()); println!(); for trace in traces.iter().rev() { print_trace(trace, false); } Ok(()) } } mod elfcore { #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct elf_siginfo { pub si_signo: ::std::os::raw::c_int, pub si_code: ::std::os::raw::c_int, pub si_errno: ::std::os::raw::c_int, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct timeval { pub tv_sec: ::std::os::raw::c_long, pub tv_usec: ::std::os::raw::c_long, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct elf_prstatus { pub pr_info: elf_siginfo, pub pr_cursig: ::std::os::raw::c_short, pub pr_sigpend: ::std::os::raw::c_ulong, pub pr_sighold: ::std::os::raw::c_ulong, pub pr_pid: ::std::os::raw::c_int, pub pr_ppid: ::std::os::raw::c_int, pub pr_pgrp: ::std::os::raw::c_int, pub pr_sid: ::std::os::raw::c_int, pub pr_utime: timeval, pub pr_stime: timeval, pub pr_cutime: timeval, pub pr_cstime: timeval, // TODO: has registers next for thread next - don't need them right now, but if we want to do // unwinding we will } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct elf_prpsinfo { pub pr_state: ::std::os::raw::c_char, pub pr_sname: ::std::os::raw::c_char, pub pr_zomb: ::std::os::raw::c_char, pub pr_nice: ::std::os::raw::c_char, pub pr_flag: ::std::os::raw::c_ulong, pub pr_uid: ::std::os::raw::c_uint, pub pr_gid: ::std::os::raw::c_uint, pub pr_pid: ::std::os::raw::c_int, pub pr_ppid: ::std::os::raw::c_int, pub pr_pgrp: ::std::os::raw::c_int, pub pr_sid: ::std::os::raw::c_int, pub pr_fname: [::std::os::raw::c_uchar; 16usize], pub pr_psargs: [::std::os::raw::c_uchar; 80usize], } } #[cfg(test)] mod test { use super::*; use py_spy_testdata::get_coredump_path; #[cfg(target_pointer_width = "64")] #[test] fn test_coredump() { // we won't have the python binary for the core dump here, // so we can't (yet) figure out the interpreter address & version. // Manually specify here to test out instead let core = CoreDump::new(&get_coredump_path("python_3_9_threads")).unwrap(); let version = Version { major: 3, minor: 9, patch: 13, release_flags: "".to_owned(), build_metadata: None, }; let python_core = PythonCoreDump { core, version, interpreter_address: 0x000055a8293dbe20, threadstate_address: 0x000055a82745fe18, }; let config = Config::default(); let traces = python_core.get_stack(&config).unwrap(); // should have two threads assert_eq!(traces.len(), 2); let main_thread = &traces[1]; assert_eq!(main_thread.frames.len(), 1); assert_eq!(main_thread.frames[0].name, ""); assert_eq!(main_thread.thread_name, Some("MainThread".to_owned())); let child_thread = &traces[0]; assert_eq!(child_thread.frames.len(), 5); assert_eq!(child_thread.frames[0].name, "dump_sum"); assert_eq!(child_thread.frames[0].line, 16); assert_eq!(child_thread.thread_name, Some("child_thread".to_owned())); } } ================================================ FILE: src/cython.rs ================================================ use regex::Regex; use std::collections::{BTreeMap, HashMap}; use anyhow::Error; use lazy_static::lazy_static; use crate::stack_trace::Frame; use crate::utils::resolve_filename; pub struct SourceMaps { maps: HashMap>, } impl SourceMaps { pub fn new() -> SourceMaps { let maps = HashMap::new(); SourceMaps { maps } } pub fn translate(&mut self, frame: &mut Frame) { if self.translate_frame(frame) { self.load_map(frame); self.translate_frame(frame); } } // tries to replace the frame using a cython sourcemap if possible // returns true if the corresponding cython sourcemap hasn't been loaded yet fn translate_frame(&mut self, frame: &mut Frame) -> bool { let line = frame.line as u32; if line == 0 { return false; } if let Some(map) = self.maps.get(&frame.filename) { if let Some(map) = map { if let Some((file, line)) = map.lookup(line) { frame.filename = file.clone(); frame.line = *line as i32; } } return false; } true } // loads the corresponding cython source map for the frame fn load_map(&mut self, frame: &Frame) { if !(frame.filename.ends_with(".cpp") || frame.filename.ends_with(".c")) { self.maps.insert(frame.filename.clone(), None); return; } let map = match SourceMap::new(&frame.filename, &frame.module) { Ok(map) => map, Err(e) => { info!("Failed to load cython file {}: {:?}", &frame.filename, e); self.maps.insert(frame.filename.clone(), None); return; } }; self.maps.insert(frame.filename.clone(), Some(map)); } } struct SourceMap { lookup: BTreeMap, } impl SourceMap { pub fn new(filename: &str, module: &Option) -> Result { let contents = std::fs::read_to_string(filename)?; SourceMap::from_contents(&contents, filename, module) } pub fn from_contents( contents: &str, cpp_filename: &str, module: &Option, ) -> Result { lazy_static! { static ref RE: Regex = Regex::new(r#"^\s*/\* "(.+\..+)":([0-9]+)"#).unwrap(); } let mut lookup = BTreeMap::new(); let mut resolved: HashMap = HashMap::new(); let mut line_count = 0; for (lineno, line) in contents.lines().enumerate() { if let Some(captures) = RE.captures(line) { let cython_file = captures.get(1).map_or("", |m| m.as_str()); let cython_line = captures.get(2).map_or("", |m| m.as_str()); if let Ok(cython_line) = cython_line.parse::() { // try resolving the cython filename let filename = match resolved.get(cython_file) { Some(filename) => filename.clone(), None => { let filename = resolve_cython_file(cpp_filename, cython_file, module); resolved.insert(cython_file.to_string(), filename.clone()); filename } }; lookup.insert(lineno as u32, (filename, cython_line)); } } line_count += 1; } lookup.insert(line_count + 1, ("".to_owned(), 0)); Ok(SourceMap { lookup }) } pub fn lookup(&self, lineno: u32) -> Option<&(String, u32)> { match self.lookup.range(..lineno).next_back() { // handle EOF Some((_, (_, 0))) => None, Some((_, val)) => Some(val), None => None, } } } pub fn ignore_frame(name: &str) -> bool { let ignorable = [ "__Pyx_PyFunction_FastCallDict", "__Pyx_PyObject_CallOneArg", "__Pyx_PyObject_Call", "__pyx_FusedFunction_call", ]; ignorable.iter().any(|&f| f == name) } pub fn demangle(name: &str) -> &str { // slice off any leading cython prefix. let prefixes = [ "__pyx_fuse_1_0__pyx_pw", "__pyx_fuse_0__pyx_f", "__pyx_fuse_1__pyx_f", "__pyx_pf", "__pyx_pw", "__pyx_f", "___pyx_f", "___pyx_pw", ]; let mut current = match prefixes.iter().find(|&prefix| name.starts_with(prefix)) { Some(prefix) => &name[prefix.len()..], None => return name, }; let mut next = current; // get the function name from the cython mangled string (removing module/file/class // prefixes) loop { let mut chars = next.chars(); if chars.next() != Some('_') { break; } let mut digit_index = 1; for ch in chars { if !ch.is_ascii_digit() { break; } digit_index += 1; } if digit_index == 1 { break; } match &next[1..digit_index].parse::() { Ok(digits) => { current = &next[digit_index..]; if digits + digit_index >= current.len() { break; } next = &next[digits + digit_index..]; } Err(_) => break, }; } debug!("cython_demangle(\"{}\") -> \"{}\"", name, current); current } fn resolve_cython_file( cpp_filename: &str, cython_filename: &str, module: &Option, ) -> String { let cython_path = std::path::PathBuf::from(cython_filename); if let Some(ext) = cython_path.extension() { let mut path_buf = std::path::PathBuf::from(cpp_filename); path_buf.set_extension(ext); if path_buf.ends_with(&cython_path) && path_buf.exists() { return path_buf.to_string_lossy().to_string(); } } match module { Some(module) => { resolve_filename(cython_filename, module).unwrap_or_else(|| cython_filename.to_owned()) } None => cython_filename.to_owned(), } } #[cfg(test)] mod tests { use super::*; #[test] fn test_demangle() { // all of these were wrong at certain points when writing cython_demangle =( assert_eq!( demangle("__pyx_pf_8implicit_4_als_30_least_squares_cg"), "_least_squares_cg" ); assert_eq!( demangle("__pyx_pw_8implicit_4_als_5least_squares_cg"), "least_squares_cg" ); assert_eq!( demangle("__pyx_fuse_1_0__pyx_pw_8implicit_4_als_31_least_squares_cg"), "_least_squares_cg" ); assert_eq!( demangle("__pyx_f_6mtrand_cont0_array"), "mtrand_cont0_array" ); // in both of these cases we should ideally slice off the module (_als/bpr), but it gets tricky // implementation wise assert_eq!( demangle("__pyx_fuse_0__pyx_f_8implicit_4_als_axpy"), "_als_axpy" ); assert_eq!( demangle("__pyx_fuse_1__pyx_f_8implicit_3bpr_has_non_zero"), "bpr_has_non_zero" ); } #[test] fn test_source_map() { let map = SourceMap::from_contents( include_str!("../ci/testdata/cython_test.c"), "cython_test.c", &None, ) .unwrap(); // we don't have info on cython line numbers until line 1261 assert_eq!(map.lookup(1000), None); // past the end of the file should also return none assert_eq!(map.lookup(10000), None); let lookup = |lineno: u32, cython_file: &str, cython_line: u32| match map.lookup(lineno) { Some((file, line)) => { assert_eq!(file, cython_file); assert_eq!(line, &cython_line); } None => { panic!( "Failed to lookup line {} (expected {}:{})", lineno, cython_file, cython_line ); } }; lookup(1298, "cython_test.pyx", 6); lookup(1647, "cython_test.pyx", 10); lookup(1763, "cython_test.pyx", 9); } } ================================================ FILE: src/dump.rs ================================================ use anyhow::Error; use console::{style, Term}; use crate::config::Config; use crate::python_spy::PythonSpy; use crate::stack_trace::StackTrace; use remoteprocess::Pid; pub fn print_traces(pid: Pid, config: &Config, parent: Option) -> Result<(), Error> { let mut process = PythonSpy::new(pid, config)?; if config.dump_json { let traces = process.get_stack_traces()?; println!("{}", serde_json::to_string_pretty(&traces)?); return Ok(()); } println!( "Process {}: {}", style(process.pid).bold().yellow(), process.process.cmdline()?.join(" ") ); println!( "Python v{} ({})", style(&process.version).bold(), style(process.process.exe()?).dim() ); if let Some(parentpid) = parent { let parentprocess = remoteprocess::Process::new(parentpid)?; println!( "Parent Process {}: {}", style(parentpid).bold().yellow(), parentprocess.cmdline()?.join(" ") ); } println!(); let traces = process.get_stack_traces()?; for trace in traces.iter().rev() { print_trace(trace, true); if config.subprocesses { for (childpid, parentpid) in process .process .child_processes() .expect("failed to get subprocesses") { let term = Term::stdout(); let (_, width) = term.size(); println!("\n{}", &style("-".repeat(width as usize)).dim()); // child_processes() returns the whole process tree, since we're recursing here // though we could end up printing grandchild processes multiple times. Limit down // to just once if parentpid == pid { print_traces(childpid, config, Some(parentpid))?; } } } } Ok(()) } pub fn print_trace(trace: &StackTrace, include_activity: bool) { let thread_id = trace.format_threadid(); let status = if include_activity { format!(" ({})", trace.status_str()) } else if trace.owns_gil { " (gil)".to_owned() } else { "".to_owned() }; match trace.thread_name.as_ref() { Some(name) => { println!( "Thread {}{}: \"{}\"", style(thread_id).bold().yellow(), status, name ); } None => { println!("Thread {}{}", style(thread_id).bold().yellow(), status); } }; for frame in &trace.frames { let filename = match &frame.short_filename { Some(f) => f, None => &frame.filename, }; if frame.line != 0 { println!( " {} ({}:{})", style(&frame.name).green(), style(&filename).cyan(), style(frame.line).dim() ); } else { println!( " {} ({})", style(&frame.name).green(), style(&filename).cyan() ); } if let Some(locals) = &frame.locals { let mut shown_args = false; let mut shown_locals = false; for local in locals { if local.arg && !shown_args { println!(" {}", style("Arguments:").dim()); shown_args = true; } else if !local.arg && !shown_locals { println!(" {}", style("Locals:").dim()); shown_locals = true; } let repr = local.repr.as_deref().unwrap_or("?"); println!(" {}: {}", local.name, repr); } } } } ================================================ FILE: src/flamegraph.rs ================================================ // This code is taken from the flamegraph.rs from rbspy // https://github.com/rbspy/rbspy/tree/master/src/ui/flamegraph.rs // licensed under the MIT License: /* MIT License Copyright (c) 2016 Julia Evans, Kamal Marhubi Portions (continuous integration setup) Copyright (c) 2016 Jorge Aparicio Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ use std::collections::HashMap; use std::io::Write; use anyhow::Error; use inferno::flamegraph::{Direction, Options}; use crate::stack_trace::StackTrace; pub struct Flamegraph { pub counts: HashMap, pub show_linenumbers: bool, } impl Flamegraph { pub fn new(show_linenumbers: bool) -> Flamegraph { Flamegraph { counts: HashMap::new(), show_linenumbers, } } pub fn increment(&mut self, trace: &StackTrace) -> std::io::Result<()> { // convert the frame into a single ';' delimited String let frame = trace .frames .iter() .rev() .map(|frame| { let filename = match &frame.short_filename { Some(f) => f, None => &frame.filename, }; if self.show_linenumbers && frame.line != 0 { format!("{} ({}:{})", frame.name, filename, frame.line) } else if !filename.is_empty() { format!("{} ({})", frame.name, filename) } else { frame.name.clone() } }) .collect::>() .join(";"); // update counts for that frame *self.counts.entry(frame).or_insert(0) += 1; Ok(()) } fn get_lines(&self) -> Vec { self.counts .iter() .map(|(k, v)| format!("{k} {v}")) .collect() } pub fn write(&self, w: &mut dyn Write) -> Result<(), Error> { let mut opts = Options::default(); opts.direction = Direction::Inverted; opts.min_width = 0.1; opts.title = std::env::args().collect::>().join(" "); let lines = self.get_lines(); inferno::flamegraph::from_lines(&mut opts, lines.iter().map(|x| x.as_str()), w) .map_err(|e| format_err!("Failed to write flamegraph: {}", e))?; Ok(()) } pub fn write_raw(&self, w: &mut dyn Write) -> Result<(), Error> { for line in self.get_lines() { w.write_all(line.as_bytes())?; w.write_all(b"\n")?; } Ok(()) } } ================================================ FILE: src/lib.rs ================================================ //! py-spy: a sampling profiler for python programs //! //! This crate lets you use py-spy as a rust library, and gather stack traces from //! your python process programmatically. //! //! # Example: //! //! ```rust,no_run //! fn print_python_stacks(pid: py_spy::Pid) -> Result<(), anyhow::Error> { //! // Create a new PythonSpy object with the default config options //! let config = py_spy::Config::default(); //! let mut process = py_spy::PythonSpy::new(pid, &config)?; //! //! // get stack traces for each thread in the process //! let traces = process.get_stack_traces()?; //! //! // Print out the python stack for each thread //! for trace in traces { //! println!("Thread {:#X} ({})", trace.thread_id, trace.status_str()); //! for frame in &trace.frames { //! println!("\t {} ({}:{})", frame.name, frame.filename, frame.line); //! } //! } //! Ok(()) //! } //! ``` #[macro_use] extern crate anyhow; #[macro_use] extern crate log; pub mod binary_parser; pub mod config; #[cfg(target_os = "linux")] pub mod coredump; #[cfg(feature = "unwind")] mod cython; pub mod dump; #[cfg(feature = "unwind")] mod native_stack_trace; mod python_bindings; mod python_data_access; mod python_interpreters; pub mod python_process_info; pub mod python_spy; mod python_threading; pub mod sampler; pub mod stack_trace; pub mod timer; mod utils; mod version; pub use config::Config; pub use python_spy::PythonSpy; pub use remoteprocess::Pid; pub use stack_trace::Frame; pub use stack_trace::StackTrace; ================================================ FILE: src/main.rs ================================================ #[macro_use] extern crate anyhow; #[macro_use] extern crate log; mod binary_parser; mod chrometrace; mod config; mod console_viewer; #[cfg(target_os = "linux")] mod coredump; #[cfg(feature = "unwind")] mod cython; mod dump; mod flamegraph; #[cfg(feature = "unwind")] mod native_stack_trace; mod python_bindings; mod python_data_access; mod python_interpreters; mod python_process_info; mod python_spy; mod python_threading; mod sampler; mod speedscope; mod stack_trace; mod timer; mod utils; mod version; use std::io::{Read, Write}; use std::sync::atomic::{AtomicBool, Ordering}; use std::sync::Arc; use std::time::Duration; use anyhow::Error; use console::style; use config::{Config, FileFormat, RecordDuration}; use console_viewer::ConsoleViewer; use stack_trace::{Frame, StackTrace}; use chrono::{Local, SecondsFormat}; #[cfg(unix)] fn permission_denied(err: &Error) -> bool { err.chain().any(|cause| { if let Some(ioerror) = cause.downcast_ref::() { ioerror.kind() == std::io::ErrorKind::PermissionDenied } else if let Some(remoteprocess::Error::IOError(ioerror)) = cause.downcast_ref::() { ioerror.kind() == std::io::ErrorKind::PermissionDenied } else { false } }) } fn sample_console(pid: remoteprocess::Pid, config: &Config) -> Result<(), Error> { let sampler = sampler::Sampler::new(pid, config)?; let display = match remoteprocess::Process::new(pid)?.cmdline() { Ok(cmdline) => cmdline.join(" "), Err(_) => format!("Pid {pid}"), }; let mut console = ConsoleViewer::new(config.show_line_numbers, &display, &sampler.version, config)?; for sample in sampler { if let Some(elapsed) = sample.late { console.increment_late_sample(elapsed); } if let Some(errors) = sample.sampling_errors { for (_, error) in errors { console.increment_error(&error)? } } console.increment(&sample.traces)?; } if !config.subprocesses { println!("\nprocess {pid} ended"); } Ok(()) } pub trait Recorder { fn increment(&mut self, trace: &StackTrace) -> Result<(), Error>; fn write(&self, w: &mut dyn Write) -> Result<(), Error>; } impl Recorder for speedscope::Stats { fn increment(&mut self, trace: &StackTrace) -> Result<(), Error> { Ok(self.record(trace)?) } fn write(&self, w: &mut dyn Write) -> Result<(), Error> { self.write(w) } } impl Recorder for flamegraph::Flamegraph { fn increment(&mut self, trace: &StackTrace) -> Result<(), Error> { Ok(self.increment(trace)?) } fn write(&self, w: &mut dyn Write) -> Result<(), Error> { self.write(w) } } impl Recorder for chrometrace::Chrometrace { fn increment(&mut self, trace: &StackTrace) -> Result<(), Error> { Ok(self.increment(trace)?) } fn write(&self, w: &mut dyn Write) -> Result<(), Error> { self.write(w) } } pub struct RawFlamegraph(flamegraph::Flamegraph); impl Recorder for RawFlamegraph { fn increment(&mut self, trace: &StackTrace) -> Result<(), Error> { Ok(self.0.increment(trace)?) } fn write(&self, w: &mut dyn Write) -> Result<(), Error> { self.0.write_raw(w) } } fn record_samples(pid: remoteprocess::Pid, config: &Config) -> Result<(), Error> { let mut output: Box = match config.format { Some(FileFormat::flamegraph) => { Box::new(flamegraph::Flamegraph::new(config.show_line_numbers)) } Some(FileFormat::speedscope) => Box::new(speedscope::Stats::new(config)), Some(FileFormat::raw) => Box::new(RawFlamegraph(flamegraph::Flamegraph::new( config.show_line_numbers, ))), Some(FileFormat::chrometrace) => { Box::new(chrometrace::Chrometrace::new(config.show_line_numbers)) } None => return Err(format_err!("A file format is required to record samples")), }; let filename = match config.filename.clone() { Some(filename) => filename, None => { let ext = match config.format.as_ref() { Some(FileFormat::flamegraph) => "svg", Some(FileFormat::speedscope) => "json", Some(FileFormat::raw) => "txt", Some(FileFormat::chrometrace) => "json", None => return Err(format_err!("A file format is required to record samples")), }; let local_time = Local::now().to_rfc3339_opts(SecondsFormat::Secs, true); let name = match config.python_program.as_ref() { Some(prog) => prog[0].to_string(), None => match config.pid.as_ref() { Some(pid) => pid.to_string(), None => String::from("unknown"), }, }; format!("{name}-{local_time}.{ext}") } }; let sampler = sampler::Sampler::new(pid, config)?; // if we're not showing a progress bar, it's probably because we've spawned the process and // are displaying its stderr/stdout. In that case add a prefix to our println messages so // that we can distinguish let lede = if config.hide_progress { format!("{}{} ", style("py-spy").bold().green(), style(">").dim()) } else { "".to_owned() }; let max_intervals = match &config.duration { RecordDuration::Unlimited => { println!( "{}Sampling process {} times a second. Press Control-C to exit.", lede, config.sampling_rate ); None } RecordDuration::Seconds(sec) => { println!( "{}Sampling process {} times a second for {} seconds. Press Control-C to exit.", lede, config.sampling_rate, sec ); Some(sec * config.sampling_rate) } }; use indicatif::ProgressBar; let progress = match (config.hide_progress, &config.duration) { (true, _) => ProgressBar::hidden(), (false, RecordDuration::Seconds(samples)) => ProgressBar::new(*samples), (false, RecordDuration::Unlimited) => { #[allow(clippy::let_and_return)] let progress = ProgressBar::new_spinner(); // The spinner on windows doesn't look great: was replaced by a [?] character at least on // my system. Replace unicode spinners with just how many seconds have elapsed #[cfg(windows)] progress.set_style( indicatif::ProgressStyle::default_spinner() .template("[{elapsed}] {msg}") .unwrap(), ); progress } }; let mut errors = 0; let mut intervals = 0; let mut samples = 0; println!(); let running = Arc::new(AtomicBool::new(true)); let r = running.clone(); ctrlc::set_handler(move || { r.store(false, Ordering::SeqCst); })?; let mut exit_message = "Stopped sampling because process exited"; let mut last_late_message = std::time::Instant::now(); for mut sample in sampler { if let Some(delay) = sample.late { if delay > Duration::from_secs(1) { if config.hide_progress { // display a message if we're late, but don't spam the log let now = std::time::Instant::now(); if now - last_late_message > Duration::from_secs(1) { last_late_message = now; println!("{lede}{delay:.2?} behind in sampling, results may be inaccurate. Try reducing the sampling rate") } } else { let term = console::Term::stdout(); term.move_cursor_up(2)?; println!("{delay:.2?} behind in sampling, results may be inaccurate. Try reducing the sampling rate."); term.move_cursor_down(1)?; } } } if !running.load(Ordering::SeqCst) { exit_message = "Stopped sampling because Control-C pressed"; break; } intervals += 1; if let Some(max_intervals) = max_intervals { if intervals >= max_intervals { exit_message = ""; break; } } for trace in sample.traces.iter_mut() { if !(config.include_idle || trace.active) { continue; } if config.gil_only && !trace.owns_gil { continue; } if config.include_thread_ids { let threadid = trace.format_threadid(); let thread_fmt = if let Some(thread_name) = &trace.thread_name { format!("thread ({threadid}): {thread_name}") } else { format!("thread ({threadid})") }; trace.frames.push(Frame { name: thread_fmt, filename: String::from(""), module: None, short_filename: None, line: 0, locals: None, is_entry: true, is_shim_entry: true, }); } if let Some(process_info) = trace.process_info.as_ref() { trace.frames.push(process_info.to_frame()); let mut parent = process_info.parent.as_ref(); while parent.is_some() { if let Some(process_info) = parent { trace.frames.push(process_info.to_frame()); parent = process_info.parent.as_ref(); } } } samples += 1; output.increment(trace)?; } if let Some(sampling_errors) = sample.sampling_errors { for (pid, e) in sampling_errors { warn!("Failed to get stack trace from {}: {}", pid, e); errors += 1; } } if config.duration == RecordDuration::Unlimited { let msg = if errors > 0 { format!("Collected {samples} samples ({errors} errors)") } else { format!("Collected {samples} samples") }; progress.set_message(msg); } progress.inc(1); } progress.finish(); // write out a message here (so as not to interfere with progress bar) if we ended earlier if !exit_message.is_empty() { println!("\n{lede}{exit_message}"); } { let mut out_file = std::fs::File::create(&filename)?; output.write(&mut out_file)?; } match config.format.as_ref().unwrap() { FileFormat::flamegraph => { println!( "{lede}Wrote flamegraph data to '{filename}'. Samples: {samples} Errors: {errors}" ); // open generated flame graph in the browser on OSX (theory being that on linux // you might be SSH'ed into a server somewhere and this isn't desired, but on // that is pretty unlikely for osx) (note to self: xdg-open will open on linux) #[cfg(target_os = "macos")] std::process::Command::new("open").arg(&filename).spawn()?; } FileFormat::speedscope => { println!( "{lede}Wrote speedscope file to '{filename}'. Samples: {samples} Errors: {errors}" ); println!("{lede}Visit https://www.speedscope.app/ to view"); } FileFormat::raw => { println!( "{lede}Wrote raw flamegraph data to '{filename}'. Samples: {samples} Errors: {errors}" ); println!("{lede}You can use the flamegraph.pl script from https://github.com/brendangregg/flamegraph to generate a SVG"); } FileFormat::chrometrace => { println!( "{lede}Wrote chrome trace to '{filename}'. Samples: {samples} Errors: {errors}" ); println!("{lede}Visit chrome://tracing or https://ui.perfetto.dev/ to view"); } }; Ok(()) } fn run_spy_command(pid: remoteprocess::Pid, config: &config::Config) -> Result<(), Error> { match config.command.as_ref() { "dump" => { dump::print_traces(pid, config, None)?; } "record" => { record_samples(pid, config)?; } "top" => { sample_console(pid, config)?; } _ => { // shouldn't happen return Err(format_err!("Unknown command {}", config.command)); } } Ok(()) } fn pyspy_main() -> Result<(), Error> { let config = config::Config::from_commandline(); #[cfg(target_os = "macos")] { if unsafe { libc::geteuid() } != 0 { eprintln!("This program requires root on OSX."); eprintln!("Try running again with elevated permissions by going 'sudo !!'"); std::process::exit(1) } } #[cfg(target_os = "linux")] { if let Some(ref core_filename) = config.core_filename { let core = coredump::PythonCoreDump::new(std::path::Path::new(&core_filename))?; let traces = core.get_stack(&config)?; return core.print_traces(&traces, &config); } } if let Some(pid) = config.pid { run_spy_command(pid, &config)?; } else if let Some(ref subprocess) = config.python_program { // Dump out stdout/stderr from the process to a temp file, so we can view it later if needed let mut process_output = tempfile::NamedTempFile::new()?; let mut command = std::process::Command::new(&subprocess[0]); #[cfg(unix)] { // Drop root permissions if possible: https://github.com/benfred/py-spy/issues/116 if unsafe { libc::geteuid() } == 0 { if let Ok(sudo_uid) = std::env::var("SUDO_UID") { use std::os::unix::process::CommandExt; info!( "Dropping root and running python command as {}", std::env::var("SUDO_USER")? ); command.uid(sudo_uid.parse::()?); } } } let mut command = command.args(&subprocess[1..]); if config.capture_output { command = command .stdin(std::process::Stdio::null()) .stdout(process_output.reopen()?) .stderr(process_output.reopen()?) } let mut command = command .spawn() .map_err(|e| format_err!("Failed to create process '{}': {}", subprocess[0], e))?; #[cfg(target_os = "macos")] { // sleep just in case: https://jvns.ca/blog/2018/01/28/mac-freeze/ std::thread::sleep(Duration::from_millis(50)); } let result = run_spy_command(command.id() as _, &config); // check exit code of subprocess std::thread::sleep(Duration::from_millis(1)); let success = match command.try_wait()? { Some(exit) => exit.success(), // if process hasn't finished, assume success None => true, }; // if we failed for any reason, dump out stderr from child process here // (could have useful error message) if config.capture_output && (!success || result.is_err()) { let mut buffer = String::new(); if process_output.read_to_string(&mut buffer).is_ok() { eprintln!("{buffer}"); } } // kill it so we don't have dangling processes if command.kill().is_err() { // I don't actually care if we failed to kill ... most times process is already done // eprintln!("Error killing child process {}", e); } return result; } Ok(()) } fn main() { env_logger::builder() .format_timestamp_nanos() .try_init() .unwrap(); if let Err(err) = pyspy_main() { #[cfg(unix)] { if permission_denied(&err) { // Got a permission denied error, if we're not running as root - ask to use sudo if unsafe { libc::geteuid() } != 0 { eprintln!("Permission Denied: Try running again with elevated permissions by going 'sudo env \"PATH=$PATH\" !!'"); std::process::exit(1); } // We got a permission denied error running as root, check to see if we're running // as docker, and if so ask the user to check the SYS_PTRACE capability is added // Otherwise, fall through to the generic error handling #[cfg(target_os = "linux")] if let Ok(cgroups) = std::fs::read_to_string("/proc/self/cgroup") { if cgroups.contains("/docker/") { eprintln!("Permission Denied"); eprintln!("\nIt looks like you are running in a docker container. Please make sure \ you started your container with the SYS_PTRACE capability. See \ https://github.com/benfred/py-spy#how-do-i-run-py-spy-in-docker for \ more details"); std::process::exit(1); } } } } eprintln!("Error: {err}"); for (i, suberror) in err.chain().enumerate() { if i > 0 { eprintln!("Reason: {suberror}"); } } std::process::exit(1); } } ================================================ FILE: src/native_stack_trace.rs ================================================ use anyhow::Error; use std::collections::HashSet; use std::num::NonZeroUsize; use cpp_demangle::{BorrowedSymbol, DemangleOptions}; use lazy_static::lazy_static; use lru::LruCache; use remoteprocess::{self, Pid}; use crate::binary_parser::BinaryInfo; use crate::cython; use crate::stack_trace::Frame; use crate::utils::resolve_filename; pub struct NativeStack { should_reload: bool, python: Option, libpython: Option, cython_maps: cython::SourceMaps, unwinder: remoteprocess::Unwinder, symbolicator: remoteprocess::Symbolicator, // TODO: right now on windows if we don't hold on the process handle unwinding will fail #[allow(dead_code)] process: remoteprocess::Process, symbol_cache: LruCache, } impl NativeStack { pub fn new( pid: Pid, python: Option, libpython: Option, ) -> Result { let cython_maps = cython::SourceMaps::new(); let process = remoteprocess::Process::new(pid)?; let unwinder = process.unwinder()?; let symbolicator = process.symbolicator()?; Ok(NativeStack { cython_maps, unwinder, symbolicator, should_reload: false, python, libpython, process, symbol_cache: LruCache::new(NonZeroUsize::new(65536).unwrap()), }) } pub fn merge_native_thread( &mut self, frames: &Vec, thread: &remoteprocess::Thread, ) -> Result, Error> { if self.should_reload { self.symbolicator.reload()?; self.should_reload = false; } // get the native stack from the thread let native_stack = self.get_thread(thread)?; // TODO: merging the two stack together could happen outside of thread lock self.merge_native_stack(frames, native_stack) } pub fn merge_native_stack( &mut self, frames: &Vec, native_stack: Vec, ) -> Result, Error> { let mut python_frame_index = 0; let mut merged = Vec::new(); // merge the native_stack and python stack together for addr in native_stack { // check in the symbol cache if we have looked up this symbol yet let cached_symbol = self.symbol_cache.get(&addr).cloned(); // merges a remoteprocess::StackFrame into the current merged vec let is_python_addr = self.python.as_ref().map_or(false, |m| m.contains(addr)) || self.libpython.as_ref().map_or(false, |m| m.contains(addr)); let merge_frame = &mut |frame: &remoteprocess::StackFrame| { match self.get_merge_strategy(is_python_addr, frame) { MergeType::Ignore => {} MergeType::MergeNativeFrame => { if let Some(python_frame) = self.translate_native_frame(frame) { merged.push(python_frame); } } MergeType::MergePythonFrame => { // if we have a corresponding python frame for the evalframe // merge it into the stack. (if we're out of bounds a later // check will pick up - and report overall totals mismatch) // Merge all python frames until we hit one with `is_entry` (py 3.11) // or `is_entry_shim` (py 3.12+) while python_frame_index < frames.len() { merged.push(frames[python_frame_index].clone()); if frames[python_frame_index].is_entry || frames[python_frame_index].is_shim_entry { break; } python_frame_index += 1; } python_frame_index += 1; } } }; if let Some(frame) = cached_symbol { merge_frame(&frame); continue; } // Keep track of the first symbolicated frame for caching. We don't cache anything (yet) where // symoblicationg returns multiple frames for an address, like in the case of inlined function calls. // so track how many frames we get for the address, and only update cache in the happy case // of 1 frame let mut symbolicated_count = 0; let mut first_frame = None; self.symbolicator .symbolicate( addr, !is_python_addr, &mut |frame: &remoteprocess::StackFrame| { symbolicated_count += 1; if symbolicated_count == 1 { first_frame = Some(frame.clone()); } merge_frame(frame); }, ) .unwrap_or_else(|e| { if let remoteprocess::Error::NoBinaryForAddress(_) = e { debug!( "don't have a binary for symbols at 0x{:x} - reloading", addr ); self.should_reload = true; } // if we can't symbolicate, just insert a stub here. merged.push(Frame { filename: "?".to_owned(), name: format!("0x{:x}", addr), line: 0, short_filename: None, module: None, locals: None, is_entry: true, is_shim_entry: true, }); }); if symbolicated_count == 1 { self.symbol_cache.put(addr, first_frame.unwrap()); } } if python_frame_index != frames.len() { if python_frame_index == 0 { // I've seen a problem come up a bunch where we only get 1-2 native stack traces and then it fails // (with a valid python stack trace on top of that). both the gimli and libunwind unwinder don't // return the full stack, and connecting up to the process with GDB brings a corrupt stack error: // from /home/ben/anaconda3/lib/python3.7/site-packages/numpy/core/../../../../libmkl_avx512.so // Backtrace stopped: previous frame inner to this frame (corrupt stack?) // // rather than fail here, lets just insert the python frames after the native frames for frame in frames { merged.push(frame.clone()); } } else if python_frame_index == frames.len() + 1 { // if we have seen exactly one more python frame in the native stack than the python stack - let it go. // (can happen when the python stack has been unwound, but haven't exited the PyEvalFrame function // yet) info!( "Have {} native and {} python threads in stack - allowing for now", python_frame_index, frames.len() ); } else { return Err(format_err!( "Failed to merge native and python frames (Have {} native and {} python)", python_frame_index, frames.len() )); } } // TODO: can this by merged into translate_frame? for frame in merged.iter_mut() { self.cython_maps.translate(frame); } Ok(merged) } fn get_merge_strategy( &self, check_python: bool, frame: &remoteprocess::StackFrame, ) -> MergeType { if check_python { if let Some(ref function) = frame.function { // We want to include some internal python functions. For example, calls like time.sleep // or os.kill etc are implemented as builtins in the interpreter and filtering them out // is misleading. Create a set of whitelisted python function prefixes to include lazy_static! { static ref WHITELISTED_PREFIXES: HashSet<&'static str> = { let mut prefixes = HashSet::new(); prefixes.insert("time"); prefixes.insert("sys"); prefixes.insert("gc"); prefixes.insert("os"); prefixes.insert("unicode"); prefixes.insert("thread"); prefixes.insert("stringio"); prefixes.insert("sre"); // likewise reasoning about lock contention inside python is also useful prefixes.insert("PyGilState"); prefixes.insert("PyThread"); prefixes.insert("lock"); prefixes }; } // Figure out the merge type by looking at the function name, frames that // are used in evaluating python code are ignored, aside from PyEval_EvalFrame* // which is replaced by the function from the python stack // note: we're splitting on both _ and . to handle symbols like // _PyEval_EvalFrameDefault.cold.2962 let mut tokens = function.split(&['_', '.'][..]).filter(|&x| !x.is_empty()); match tokens.next() { Some("PyEval") => match tokens.next() { Some("EvalFrameDefault") => MergeType::MergePythonFrame, Some("EvalFrameEx") => MergeType::MergePythonFrame, _ => MergeType::Ignore, }, Some(prefix) if WHITELISTED_PREFIXES.contains(prefix) => { MergeType::MergeNativeFrame } _ => MergeType::Ignore, } } else { // is this correct? if we don't have a function name and in python binary should ignore? MergeType::Ignore } } else { MergeType::MergeNativeFrame } } /// translates a native frame into a optional frame. none indicates we should ignore this frame fn translate_native_frame(&self, frame: &remoteprocess::StackFrame) -> Option { match &frame.function { Some(func) => { if ignore_frame(func, &frame.module) { return None; } // Get the filename/line/function name here let line = frame.line.unwrap_or(0) as i32; // try to resolve the filename relative to the module if given let filename = match frame.filename.as_ref() { Some(filename) => resolve_filename(filename, &frame.module) .unwrap_or_else(|| filename.clone()), None => frame.module.clone(), }; let mut demangled = None; if func.starts_with('_') { if let Ok((sym, _)) = BorrowedSymbol::with_tail(func.as_bytes()) { let options = DemangleOptions::new().no_params().no_return_type(); if let Ok(sym) = sym.demangle(&options) { demangled = Some(sym); } } } let name = demangled.as_ref().unwrap_or(func); if cython::ignore_frame(name) { return None; } let name = cython::demangle(name).to_owned(); Some(Frame { filename, line, name, short_filename: None, module: Some(frame.module.clone()), locals: None, is_entry: true, is_shim_entry: true, }) } None => Some(Frame { filename: frame.module.clone(), name: format!("0x{:x}", frame.addr), locals: None, line: 0, short_filename: None, module: Some(frame.module.clone()), is_entry: true, is_shim_entry: true, }), } } fn get_thread(&mut self, thread: &remoteprocess::Thread) -> Result, Error> { let mut stack = Vec::new(); for ip in self.unwinder.cursor(thread)? { stack.push(ip?); } Ok(stack) } } #[derive(Debug)] enum MergeType { Ignore, MergePythonFrame, MergeNativeFrame, } // the intent here is to remove top-level libc or pthreads calls // from the stack traces. This almost certainly can be done better #[cfg(target_os = "linux")] fn ignore_frame(function: &str, module: &str) -> bool { if function == "__libc_start_main" && module.contains("/libc") { return true; } if function == "__clone" && module.contains("/libc") { return true; } if function == "start_thread" && module.contains("/libpthread") { return true; } false } #[cfg(target_os = "macos")] fn ignore_frame(function: &str, module: &str) -> bool { if function == "_start" && module.contains("/libdyld.dylib") { return true; } if function == "__pthread_body" && module.contains("/libsystem_pthread") { return true; } if function == "_thread_start" && module.contains("/libsystem_pthread") { return true; } false } #[cfg(windows)] fn ignore_frame(function: &str, module: &str) -> bool { if function == "RtlUserThreadStart" && module.to_lowercase().ends_with("ntdll.dll") { return true; } if function == "BaseThreadInitThunk" && module.to_lowercase().ends_with("kernel32.dll") { return true; } false } ================================================ FILE: src/python_bindings/mod.rs ================================================ pub mod v2_7_15; pub mod v3_10_0; pub mod v3_11_0; pub mod v3_12_0; pub mod v3_13_0; pub mod v3_3_7; pub mod v3_5_5; pub mod v3_6_6; pub mod v3_7_0; pub mod v3_8_0; pub mod v3_9_5; // currently the PyRuntime struct used from Python 3.7 on really can't be // exposed in a cross platform way using bindgen. PyRuntime has several mutex's // as member variables, and these have different sizes depending on the operating // system and system architecture. // Instead we will define some constants here that define valid offsets for the // member variables we care about here // (note 'generate_bindings.py' has code to figure out these offsets) pub mod pyruntime { use crate::version::Version; // There aren't any OS specific members of PyRuntime before pyinterpreters.head, // so these offsets should be valid for all OS'es #[cfg(target_arch = "x86")] pub fn get_interp_head_offset(version: &Version) -> usize { match version { Version { major: 3, minor: 8, patch: 0, .. } => match version.release_flags.as_ref() { "a1" | "a2" => 16, "a3" | "a4" => 20, _ => 24, }, Version { major: 3, minor: 8..=10, .. } => 24, _ => 16, } } #[cfg(target_arch = "arm")] pub fn get_interp_head_offset(version: &Version) -> usize { match version { Version { major: 3, minor: 7, .. } => 20, _ => 28, } } #[cfg(target_pointer_width = "64")] pub fn get_interp_head_offset(version: &Version) -> usize { match version { Version { major: 3, minor: 8, patch: 0, .. } => match version.release_flags.as_ref() { "a1" | "a2" => 24, _ => 32, }, Version { major: 3, minor: 8..=10, .. } => 32, Version { major: 3, minor: 11..=12, .. } => 40, _ => 24, } } // getting gilstate.tstate_current is different for all OS // and is also different for each python version, and even // between v3.8.0a1 and v3.8.0a2 =( #[cfg(target_os = "macos")] pub fn get_tstate_current_offset(version: &Version) -> Option { match version { Version { major: 3, minor: 7, patch: 0..=3, .. } => Some(1440), Version { major: 3, minor: 7, .. } => Some(1528), Version { major: 3, minor: 8, patch: 0, .. } => match version.release_flags.as_ref() { "a1" => Some(1432), "a2" => Some(888), "a3" | "a4" => Some(1448), _ => Some(1416), }, Version { major: 3, minor: 8, .. } => Some(1416), Version { major: 3, minor: 9..=10, .. } => Some(616), Version { major: 3, minor: 11, .. } => Some(624), _ => None, } } #[cfg(all(target_os = "linux", target_arch = "x86"))] pub fn get_tstate_current_offset(version: &Version) -> Option { match version { Version { major: 3, minor: 7, .. } => Some(796), Version { major: 3, minor: 8, patch: 0, .. } => match version.release_flags.as_ref() { "a1" => Some(792), "a2" => Some(512), "a3" | "a4" => Some(800), _ => Some(788), }, Version { major: 3, minor: 8, .. } => Some(788), Version { major: 3, minor: 9..=10, .. } => Some(352), _ => None, } } #[cfg(all(target_os = "linux", target_arch = "arm"))] pub fn get_tstate_current_offset(version: &Version) -> Option { match version { Version { major: 3, minor: 7, .. } => Some(828), Version { major: 3, minor: 8, .. } => Some(804), Version { major: 3, minor: 9..=11, .. } => Some(364), _ => None, } } #[cfg(all(target_os = "linux", target_arch = "aarch64"))] pub fn get_tstate_current_offset(version: &Version) -> Option { match version { Version { major: 3, minor: 7, patch: 0..=3, .. } => Some(1408), Version { major: 3, minor: 7, .. } => Some(1496), Version { major: 3, minor: 8, .. } => Some(1384), Version { major: 3, minor: 9..=10, .. } => Some(584), Version { major: 3, minor: 11, .. } => Some(592), _ => None, } } #[cfg(all(target_os = "linux", target_arch = "x86_64"))] pub fn get_tstate_current_offset(version: &Version) -> Option { match version { Version { major: 3, minor: 7, patch: 0..=3, .. } => Some(1392), Version { major: 3, minor: 7, .. } => Some(1480), Version { major: 3, minor: 8, patch: 0, .. } => match version.release_flags.as_ref() { "a1" => Some(1384), "a2" => Some(840), "a3" | "a4" => Some(1400), _ => Some(1368), }, Version { major: 3, minor: 8, .. } => match version.build_metadata.as_deref() { Some("cinder") => Some(1384), _ => Some(1368), }, Version { major: 3, minor: 9..=10, .. } => Some(568), Version { major: 3, minor: 11, .. } => Some(576), _ => None, } } #[cfg(all( target_os = "linux", any( target_arch = "powerpc64", target_arch = "powerpc", target_arch = "mips" ) ))] pub fn get_tstate_current_offset(version: &Version) -> Option { None } #[cfg(windows)] pub fn get_tstate_current_offset(version: &Version) -> Option { match version { Version { major: 3, minor: 7, patch: 0..=3, .. } => Some(1320), Version { major: 3, minor: 8, patch: 0, .. } => match version.release_flags.as_ref() { "a1" => Some(1312), "a2" => Some(768), "a3" | "a4" => Some(1328), _ => Some(1296), }, Version { major: 3, minor: 8, .. } => Some(1296), Version { major: 3, minor: 9..=10, .. } => Some(496), Version { major: 3, minor: 11, .. } => Some(504), _ => None, } } #[cfg(target_os = "freebsd")] pub fn get_tstate_current_offset(version: &Version) -> Option { match version { Version { major: 3, minor: 7, patch: 0..=3, .. } => Some(1248), Version { major: 3, minor: 7, patch: 4..=7, .. } => Some(1336), Version { major: 3, minor: 8, patch: 0, .. } => match version.release_flags.as_ref() { "a1" => Some(1240), "a2" => Some(696), "a3" | "a4" => Some(1256), _ => Some(1224), }, Version { major: 3, minor: 8, .. } => Some(1224), Version { major: 3, minor: 9..=10, .. } => Some(424), Version { major: 3, minor: 11, .. } => Some(432), _ => None, } } } ================================================ FILE: src/python_bindings/v2_7_15.rs ================================================ // Generated bindings for python v2.7.15 #![allow(dead_code)] #![allow(non_upper_case_globals)] #![allow(non_camel_case_types)] #![allow(non_snake_case)] #![allow(clippy::useless_transmute)] #![allow(clippy::default_trait_access)] #![allow(clippy::cast_lossless)] #![allow(clippy::trivially_copy_pass_by_ref)] #![allow(clippy::upper_case_acronyms)] /* automatically generated by rust-bindgen */ pub type __int64_t = ::std::os::raw::c_longlong; pub type __darwin_ssize_t = ::std::os::raw::c_long; pub type __darwin_off_t = __int64_t; pub type fpos_t = __darwin_off_t; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct __sbuf { pub _base: *mut ::std::os::raw::c_uchar, pub _size: ::std::os::raw::c_int, } impl Default for __sbuf { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct __sFILEX { _unused: [u8; 0], } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct __sFILE { pub _p: *mut ::std::os::raw::c_uchar, pub _r: ::std::os::raw::c_int, pub _w: ::std::os::raw::c_int, pub _flags: ::std::os::raw::c_short, pub _file: ::std::os::raw::c_short, pub _bf: __sbuf, pub _lbfsize: ::std::os::raw::c_int, pub _cookie: *mut ::std::os::raw::c_void, pub _close: ::std::option::Option< unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, >, pub _read: ::std::option::Option< unsafe extern "C" fn( arg1: *mut ::std::os::raw::c_void, arg2: *mut ::std::os::raw::c_char, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >, pub _seek: ::std::option::Option< unsafe extern "C" fn( arg1: *mut ::std::os::raw::c_void, arg2: fpos_t, arg3: ::std::os::raw::c_int, ) -> fpos_t, >, pub _write: ::std::option::Option< unsafe extern "C" fn( arg1: *mut ::std::os::raw::c_void, arg2: *const ::std::os::raw::c_char, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >, pub _ub: __sbuf, pub _extra: *mut __sFILEX, pub _ur: ::std::os::raw::c_int, pub _ubuf: [::std::os::raw::c_uchar; 3usize], pub _nbuf: [::std::os::raw::c_uchar; 1usize], pub _lb: __sbuf, pub _blksize: ::std::os::raw::c_int, pub _offset: fpos_t, } impl Default for __sFILE { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type FILE = __sFILE; pub type Py_ssize_t = isize; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _object { pub ob_refcnt: Py_ssize_t, pub ob_type: *mut _typeobject, } impl Default for _object { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyObject = _object; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyVarObject { pub ob_refcnt: Py_ssize_t, pub ob_type: *mut _typeobject, pub ob_size: Py_ssize_t, } impl Default for PyVarObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type unaryfunc = ::std::option::Option *mut PyObject>; pub type binaryfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject, >; pub type ternaryfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> *mut PyObject, >; pub type inquiry = ::std::option::Option ::std::os::raw::c_int>; pub type lenfunc = ::std::option::Option Py_ssize_t>; pub type coercion = ::std::option::Option< unsafe extern "C" fn( arg1: *mut *mut PyObject, arg2: *mut *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type ssizeargfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: Py_ssize_t) -> *mut PyObject, >; pub type ssizessizeargfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: Py_ssize_t, arg3: Py_ssize_t) -> *mut PyObject, >; pub type ssizeobjargproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: Py_ssize_t, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type ssizessizeobjargproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: Py_ssize_t, arg3: Py_ssize_t, arg4: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type objobjargproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type readbufferproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: Py_ssize_t, arg3: *mut *mut ::std::os::raw::c_void, ) -> Py_ssize_t, >; pub type writebufferproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: Py_ssize_t, arg3: *mut *mut ::std::os::raw::c_void, ) -> Py_ssize_t, >; pub type segcountproc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut Py_ssize_t) -> Py_ssize_t, >; pub type charbufferproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: Py_ssize_t, arg3: *mut *mut ::std::os::raw::c_char, ) -> Py_ssize_t, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct bufferinfo { pub buf: *mut ::std::os::raw::c_void, pub obj: *mut PyObject, pub len: Py_ssize_t, pub itemsize: Py_ssize_t, pub readonly: ::std::os::raw::c_int, pub ndim: ::std::os::raw::c_int, pub format: *mut ::std::os::raw::c_char, pub shape: *mut Py_ssize_t, pub strides: *mut Py_ssize_t, pub suboffsets: *mut Py_ssize_t, pub smalltable: [Py_ssize_t; 2usize], pub internal: *mut ::std::os::raw::c_void, } impl Default for bufferinfo { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type Py_buffer = bufferinfo; pub type getbufferproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut Py_buffer, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >; pub type releasebufferproc = ::std::option::Option; pub type objobjproc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> ::std::os::raw::c_int, >; pub type visitproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; pub type traverseproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: visitproc, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyNumberMethods { pub nb_add: binaryfunc, pub nb_subtract: binaryfunc, pub nb_multiply: binaryfunc, pub nb_divide: binaryfunc, pub nb_remainder: binaryfunc, pub nb_divmod: binaryfunc, pub nb_power: ternaryfunc, pub nb_negative: unaryfunc, pub nb_positive: unaryfunc, pub nb_absolute: unaryfunc, pub nb_nonzero: inquiry, pub nb_invert: unaryfunc, pub nb_lshift: binaryfunc, pub nb_rshift: binaryfunc, pub nb_and: binaryfunc, pub nb_xor: binaryfunc, pub nb_or: binaryfunc, pub nb_coerce: coercion, pub nb_int: unaryfunc, pub nb_long: unaryfunc, pub nb_float: unaryfunc, pub nb_oct: unaryfunc, pub nb_hex: unaryfunc, pub nb_inplace_add: binaryfunc, pub nb_inplace_subtract: binaryfunc, pub nb_inplace_multiply: binaryfunc, pub nb_inplace_divide: binaryfunc, pub nb_inplace_remainder: binaryfunc, pub nb_inplace_power: ternaryfunc, pub nb_inplace_lshift: binaryfunc, pub nb_inplace_rshift: binaryfunc, pub nb_inplace_and: binaryfunc, pub nb_inplace_xor: binaryfunc, pub nb_inplace_or: binaryfunc, pub nb_floor_divide: binaryfunc, pub nb_true_divide: binaryfunc, pub nb_inplace_floor_divide: binaryfunc, pub nb_inplace_true_divide: binaryfunc, pub nb_index: unaryfunc, } impl Default for PyNumberMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PySequenceMethods { pub sq_length: lenfunc, pub sq_concat: binaryfunc, pub sq_repeat: ssizeargfunc, pub sq_item: ssizeargfunc, pub sq_slice: ssizessizeargfunc, pub sq_ass_item: ssizeobjargproc, pub sq_ass_slice: ssizessizeobjargproc, pub sq_contains: objobjproc, pub sq_inplace_concat: binaryfunc, pub sq_inplace_repeat: ssizeargfunc, } impl Default for PySequenceMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyMappingMethods { pub mp_length: lenfunc, pub mp_subscript: binaryfunc, pub mp_ass_subscript: objobjargproc, } impl Default for PyMappingMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyBufferProcs { pub bf_getreadbuffer: readbufferproc, pub bf_getwritebuffer: writebufferproc, pub bf_getsegcount: segcountproc, pub bf_getcharbuffer: charbufferproc, pub bf_getbuffer: getbufferproc, pub bf_releasebuffer: releasebufferproc, } impl Default for PyBufferProcs { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type freefunc = ::std::option::Option; pub type destructor = ::std::option::Option; pub type printfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut FILE, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >; pub type getattrfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_char) -> *mut PyObject, >; pub type getattrofunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject, >; pub type setattrfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_char, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type setattrofunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type cmpfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> ::std::os::raw::c_int, >; pub type reprfunc = ::std::option::Option *mut PyObject>; pub type hashfunc = ::std::option::Option ::std::os::raw::c_long>; pub type richcmpfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: ::std::os::raw::c_int, ) -> *mut PyObject, >; pub type getiterfunc = ::std::option::Option *mut PyObject>; pub type iternextfunc = ::std::option::Option *mut PyObject>; pub type descrgetfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> *mut PyObject, >; pub type descrsetfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type initproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type newfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut _typeobject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> *mut PyObject, >; pub type allocfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut _typeobject, arg2: Py_ssize_t) -> *mut PyObject, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _typeobject { pub ob_refcnt: Py_ssize_t, pub ob_type: *mut _typeobject, pub ob_size: Py_ssize_t, pub tp_name: *const ::std::os::raw::c_char, pub tp_basicsize: Py_ssize_t, pub tp_itemsize: Py_ssize_t, pub tp_dealloc: destructor, pub tp_print: printfunc, pub tp_getattr: getattrfunc, pub tp_setattr: setattrfunc, pub tp_compare: cmpfunc, pub tp_repr: reprfunc, pub tp_as_number: *mut PyNumberMethods, pub tp_as_sequence: *mut PySequenceMethods, pub tp_as_mapping: *mut PyMappingMethods, pub tp_hash: hashfunc, pub tp_call: ternaryfunc, pub tp_str: reprfunc, pub tp_getattro: getattrofunc, pub tp_setattro: setattrofunc, pub tp_as_buffer: *mut PyBufferProcs, pub tp_flags: ::std::os::raw::c_long, pub tp_doc: *const ::std::os::raw::c_char, pub tp_traverse: traverseproc, pub tp_clear: inquiry, pub tp_richcompare: richcmpfunc, pub tp_weaklistoffset: Py_ssize_t, pub tp_iter: getiterfunc, pub tp_iternext: iternextfunc, pub tp_methods: *mut PyMethodDef, pub tp_members: *mut PyMemberDef, pub tp_getset: *mut PyGetSetDef, pub tp_base: *mut _typeobject, pub tp_dict: *mut PyObject, pub tp_descr_get: descrgetfunc, pub tp_descr_set: descrsetfunc, pub tp_dictoffset: Py_ssize_t, pub tp_init: initproc, pub tp_alloc: allocfunc, pub tp_new: newfunc, pub tp_free: freefunc, pub tp_is_gc: inquiry, pub tp_bases: *mut PyObject, pub tp_mro: *mut PyObject, pub tp_cache: *mut PyObject, pub tp_subclasses: *mut PyObject, pub tp_weaklist: *mut PyObject, pub tp_del: destructor, pub tp_version_tag: ::std::os::raw::c_uint, } impl Default for _typeobject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyTypeObject = _typeobject; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyIntObject { pub ob_refcnt: Py_ssize_t, pub ob_type: *mut _typeobject, pub ob_ival: ::std::os::raw::c_long, } impl Default for PyIntObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _longobject { _unused: [u8; 0], } pub type PyLongObject = _longobject; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyFloatObject { pub ob_refcnt: Py_ssize_t, pub ob_type: *mut _typeobject, pub ob_fval: f64, } impl Default for PyFloatObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyStringObject { pub ob_refcnt: Py_ssize_t, pub ob_type: *mut _typeobject, pub ob_size: Py_ssize_t, pub ob_shash: ::std::os::raw::c_long, pub ob_sstate: ::std::os::raw::c_int, pub ob_sval: [::std::os::raw::c_char; 1usize], } impl Default for PyStringObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyTupleObject { pub ob_refcnt: Py_ssize_t, pub ob_type: *mut _typeobject, pub ob_size: Py_ssize_t, pub ob_item: [*mut PyObject; 1usize], } impl Default for PyTupleObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyListObject { pub ob_refcnt: Py_ssize_t, pub ob_type: *mut _typeobject, pub ob_size: Py_ssize_t, pub ob_item: *mut *mut PyObject, pub allocated: Py_ssize_t, } impl Default for PyListObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyDictEntry { pub me_hash: Py_ssize_t, pub me_key: *mut PyObject, pub me_value: *mut PyObject, } impl Default for PyDictEntry { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyDictObject = _dictobject; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _dictobject { pub ob_refcnt: Py_ssize_t, pub ob_type: *mut _typeobject, pub ma_fill: Py_ssize_t, pub ma_used: Py_ssize_t, pub ma_mask: Py_ssize_t, pub ma_table: *mut PyDictEntry, pub ma_lookup: ::std::option::Option< unsafe extern "C" fn( mp: *mut PyDictObject, key: *mut PyObject, hash: ::std::os::raw::c_long, ) -> *mut PyDictEntry, >, pub ma_smalltable: [PyDictEntry; 8usize], } impl Default for _dictobject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyCFunction = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyMethodDef { pub ml_name: *const ::std::os::raw::c_char, pub ml_meth: PyCFunction, pub ml_flags: ::std::os::raw::c_int, pub ml_doc: *const ::std::os::raw::c_char, } impl Default for PyMethodDef { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type getter = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_void) -> *mut PyObject, >; pub type setter = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyGetSetDef { pub name: *mut ::std::os::raw::c_char, pub get: getter, pub set: setter, pub doc: *mut ::std::os::raw::c_char, pub closure: *mut ::std::os::raw::c_void, } impl Default for PyGetSetDef { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _is { pub next: *mut _is, pub tstate_head: *mut _ts, pub modules: *mut PyObject, pub sysdict: *mut PyObject, pub builtins: *mut PyObject, pub modules_reloading: *mut PyObject, pub codec_search_path: *mut PyObject, pub codec_search_cache: *mut PyObject, pub codec_error_registry: *mut PyObject, pub dlopenflags: ::std::os::raw::c_int, } impl Default for _is { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyInterpreterState = _is; pub type Py_tracefunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut _frame, arg3: ::std::os::raw::c_int, arg4: *mut PyObject, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _ts { pub next: *mut _ts, pub interp: *mut PyInterpreterState, pub frame: *mut _frame, pub recursion_depth: ::std::os::raw::c_int, pub tracing: ::std::os::raw::c_int, pub use_tracing: ::std::os::raw::c_int, pub c_profilefunc: Py_tracefunc, pub c_tracefunc: Py_tracefunc, pub c_profileobj: *mut PyObject, pub c_traceobj: *mut PyObject, pub curexc_type: *mut PyObject, pub curexc_value: *mut PyObject, pub curexc_traceback: *mut PyObject, pub exc_type: *mut PyObject, pub exc_value: *mut PyObject, pub exc_traceback: *mut PyObject, pub dict: *mut PyObject, pub tick_counter: ::std::os::raw::c_int, pub gilstate_counter: ::std::os::raw::c_int, pub async_exc: *mut PyObject, pub thread_id: ::std::os::raw::c_long, pub trash_delete_nesting: ::std::os::raw::c_int, pub trash_delete_later: *mut PyObject, } impl Default for _ts { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyThreadState = _ts; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyCodeObject { pub ob_refcnt: Py_ssize_t, pub ob_type: *mut _typeobject, pub co_argcount: ::std::os::raw::c_int, pub co_nlocals: ::std::os::raw::c_int, pub co_stacksize: ::std::os::raw::c_int, pub co_flags: ::std::os::raw::c_int, pub co_code: *mut PyObject, pub co_consts: *mut PyObject, pub co_names: *mut PyObject, pub co_varnames: *mut PyObject, pub co_freevars: *mut PyObject, pub co_cellvars: *mut PyObject, pub co_filename: *mut PyObject, pub co_name: *mut PyObject, pub co_firstlineno: ::std::os::raw::c_int, pub co_lnotab: *mut PyObject, pub co_zombieframe: *mut ::std::os::raw::c_void, pub co_weakreflist: *mut PyObject, } impl Default for PyCodeObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct PyTryBlock { pub b_type: ::std::os::raw::c_int, pub b_handler: ::std::os::raw::c_int, pub b_level: ::std::os::raw::c_int, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _frame { pub ob_refcnt: Py_ssize_t, pub ob_type: *mut _typeobject, pub ob_size: Py_ssize_t, pub f_back: *mut _frame, pub f_code: *mut PyCodeObject, pub f_builtins: *mut PyObject, pub f_globals: *mut PyObject, pub f_locals: *mut PyObject, pub f_valuestack: *mut *mut PyObject, pub f_stacktop: *mut *mut PyObject, pub f_trace: *mut PyObject, pub f_exc_type: *mut PyObject, pub f_exc_value: *mut PyObject, pub f_exc_traceback: *mut PyObject, pub f_tstate: *mut PyThreadState, pub f_lasti: ::std::os::raw::c_int, pub f_lineno: ::std::os::raw::c_int, pub f_iblock: ::std::os::raw::c_int, pub f_blockstack: [PyTryBlock; 20usize], pub f_localsplus: [*mut PyObject; 1usize], } impl Default for _frame { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyFrameObject = _frame; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct PyMemberDef { pub _address: u8, } ================================================ FILE: src/python_bindings/v3_10_0.rs ================================================ // Generated bindings for python v3.10.0rc1 #![allow(dead_code)] #![allow(non_upper_case_globals)] #![allow(non_camel_case_types)] #![allow(non_snake_case)] #![allow(clippy::useless_transmute)] #![allow(clippy::default_trait_access)] #![allow(clippy::cast_lossless)] #![allow(clippy::trivially_copy_pass_by_ref)] #![allow(clippy::upper_case_acronyms)] /* automatically generated by rust-bindgen */ #[repr(C)] #[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] pub struct __BindgenBitfieldUnit where Storage: AsRef<[u8]> + AsMut<[u8]>, { storage: Storage, align: [Align; 0], } impl __BindgenBitfieldUnit where Storage: AsRef<[u8]> + AsMut<[u8]>, { #[inline] pub fn new(storage: Storage) -> Self { Self { storage, align: [] } } #[inline] pub fn get_bit(&self, index: usize) -> bool { debug_assert!(index / 8 < self.storage.as_ref().len()); let byte_index = index / 8; let byte = self.storage.as_ref()[byte_index]; let bit_index = if cfg!(target_endian = "big") { 7 - (index % 8) } else { index % 8 }; let mask = 1 << bit_index; byte & mask == mask } #[inline] pub fn set_bit(&mut self, index: usize, val: bool) { debug_assert!(index / 8 < self.storage.as_ref().len()); let byte_index = index / 8; let byte = &mut self.storage.as_mut()[byte_index]; let bit_index = if cfg!(target_endian = "big") { 7 - (index % 8) } else { index % 8 }; let mask = 1 << bit_index; if val { *byte |= mask; } else { *byte &= !mask; } } #[inline] pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); let mut val = 0; for i in 0..(bit_width as usize) { if self.get_bit(i + bit_offset) { let index = if cfg!(target_endian = "big") { bit_width as usize - 1 - i } else { i }; val |= 1 << index; } } val } #[inline] pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); for i in 0..(bit_width as usize) { let mask = 1 << i; let val_bit_is_set = val & mask == mask; let index = if cfg!(target_endian = "big") { bit_width as usize - 1 - i } else { i }; self.set_bit(index + bit_offset, val_bit_is_set); } } } #[repr(C)] #[derive(Default)] pub struct __IncompleteArrayField(::std::marker::PhantomData, [T; 0]); impl __IncompleteArrayField { #[inline] pub fn new() -> Self { __IncompleteArrayField(::std::marker::PhantomData, []) } #[inline] pub unsafe fn as_ptr(&self) -> *const T { ::std::mem::transmute(self) } #[inline] pub unsafe fn as_mut_ptr(&mut self) -> *mut T { ::std::mem::transmute(self) } #[inline] pub unsafe fn as_slice(&self, len: usize) -> &[T] { ::std::slice::from_raw_parts(self.as_ptr(), len) } #[inline] pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] { ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len) } } impl ::std::fmt::Debug for __IncompleteArrayField { fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { fmt.write_str("__IncompleteArrayField") } } impl ::std::clone::Clone for __IncompleteArrayField { #[inline] fn clone(&self) -> Self { Self::new() } } pub type __uint8_t = ::std::os::raw::c_uchar; pub type __uint16_t = ::std::os::raw::c_ushort; pub type __uint32_t = ::std::os::raw::c_uint; pub type __int64_t = ::std::os::raw::c_long; pub type __uint64_t = ::std::os::raw::c_ulong; pub type __ssize_t = ::std::os::raw::c_long; pub type wchar_t = ::std::os::raw::c_int; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct __pthread_internal_list { pub __prev: *mut __pthread_internal_list, pub __next: *mut __pthread_internal_list, } impl Default for __pthread_internal_list { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __pthread_list_t = __pthread_internal_list; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct __pthread_mutex_s { pub __lock: ::std::os::raw::c_int, pub __count: ::std::os::raw::c_uint, pub __owner: ::std::os::raw::c_int, pub __nusers: ::std::os::raw::c_uint, pub __kind: ::std::os::raw::c_int, pub __spins: ::std::os::raw::c_short, pub __elision: ::std::os::raw::c_short, pub __list: __pthread_list_t, } impl Default for __pthread_mutex_s { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct __pthread_cond_s { pub __bindgen_anon_1: __pthread_cond_s__bindgen_ty_1, pub __bindgen_anon_2: __pthread_cond_s__bindgen_ty_2, pub __g_refs: [::std::os::raw::c_uint; 2usize], pub __g_size: [::std::os::raw::c_uint; 2usize], pub __g1_orig_size: ::std::os::raw::c_uint, pub __wrefs: ::std::os::raw::c_uint, pub __g_signals: [::std::os::raw::c_uint; 2usize], } #[repr(C)] #[derive(Copy, Clone)] pub union __pthread_cond_s__bindgen_ty_1 { pub __wseq: ::std::os::raw::c_ulonglong, pub __wseq32: __pthread_cond_s__bindgen_ty_1__bindgen_ty_1, _bindgen_union_align: u64, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct __pthread_cond_s__bindgen_ty_1__bindgen_ty_1 { pub __low: ::std::os::raw::c_uint, pub __high: ::std::os::raw::c_uint, } impl Default for __pthread_cond_s__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub union __pthread_cond_s__bindgen_ty_2 { pub __g1_start: ::std::os::raw::c_ulonglong, pub __g1_start32: __pthread_cond_s__bindgen_ty_2__bindgen_ty_1, _bindgen_union_align: u64, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct __pthread_cond_s__bindgen_ty_2__bindgen_ty_1 { pub __low: ::std::os::raw::c_uint, pub __high: ::std::os::raw::c_uint, } impl Default for __pthread_cond_s__bindgen_ty_2 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for __pthread_cond_s { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type pthread_key_t = ::std::os::raw::c_uint; #[repr(C)] #[derive(Copy, Clone)] pub union pthread_mutex_t { pub __data: __pthread_mutex_s, pub __size: [::std::os::raw::c_char; 40usize], pub __align: ::std::os::raw::c_long, _bindgen_union_align: [u64; 5usize], } impl Default for pthread_mutex_t { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub union pthread_cond_t { pub __data: __pthread_cond_s, pub __size: [::std::os::raw::c_char; 48usize], pub __align: ::std::os::raw::c_longlong, _bindgen_union_align: [u64; 6usize], } impl Default for pthread_cond_t { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type Py_ssize_t = isize; pub type Py_hash_t = Py_ssize_t; pub type PyTypeObject = _typeobject; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _object { pub ob_refcnt: Py_ssize_t, pub ob_type: *mut PyTypeObject, } impl Default for _object { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyObject = _object; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyVarObject { pub ob_base: PyObject, pub ob_size: Py_ssize_t, } impl Default for PyVarObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type unaryfunc = ::std::option::Option *mut PyObject>; pub type binaryfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject, >; pub type ternaryfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> *mut PyObject, >; pub type inquiry = ::std::option::Option ::std::os::raw::c_int>; pub type lenfunc = ::std::option::Option Py_ssize_t>; pub type ssizeargfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: Py_ssize_t) -> *mut PyObject, >; pub type ssizeobjargproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: Py_ssize_t, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type objobjargproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type objobjproc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> ::std::os::raw::c_int, >; pub type visitproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; pub type traverseproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: visitproc, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; pub type freefunc = ::std::option::Option; pub type destructor = ::std::option::Option; pub type getattrfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_char) -> *mut PyObject, >; pub type getattrofunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject, >; pub type setattrfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_char, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type setattrofunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type reprfunc = ::std::option::Option *mut PyObject>; pub type hashfunc = ::std::option::Option Py_hash_t>; pub type richcmpfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: ::std::os::raw::c_int, ) -> *mut PyObject, >; pub type getiterfunc = ::std::option::Option *mut PyObject>; pub type iternextfunc = ::std::option::Option *mut PyObject>; pub type descrgetfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> *mut PyObject, >; pub type descrsetfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type initproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type newfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyTypeObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> *mut PyObject, >; pub type allocfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyTypeObject, arg2: Py_ssize_t) -> *mut PyObject, >; pub const PySendResult_PYGEN_RETURN: PySendResult = 0; pub const PySendResult_PYGEN_ERROR: PySendResult = -1; pub const PySendResult_PYGEN_NEXT: PySendResult = 1; pub type PySendResult = i32; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct bufferinfo { pub buf: *mut ::std::os::raw::c_void, pub obj: *mut PyObject, pub len: Py_ssize_t, pub itemsize: Py_ssize_t, pub readonly: ::std::os::raw::c_int, pub ndim: ::std::os::raw::c_int, pub format: *mut ::std::os::raw::c_char, pub shape: *mut Py_ssize_t, pub strides: *mut Py_ssize_t, pub suboffsets: *mut Py_ssize_t, pub internal: *mut ::std::os::raw::c_void, } impl Default for bufferinfo { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type Py_buffer = bufferinfo; pub type getbufferproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut Py_buffer, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >; pub type releasebufferproc = ::std::option::Option; pub type vectorcallfunc = ::std::option::Option< unsafe extern "C" fn( callable: *mut PyObject, args: *const *mut PyObject, nargsf: usize, kwnames: *mut PyObject, ) -> *mut PyObject, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyNumberMethods { pub nb_add: binaryfunc, pub nb_subtract: binaryfunc, pub nb_multiply: binaryfunc, pub nb_remainder: binaryfunc, pub nb_divmod: binaryfunc, pub nb_power: ternaryfunc, pub nb_negative: unaryfunc, pub nb_positive: unaryfunc, pub nb_absolute: unaryfunc, pub nb_bool: inquiry, pub nb_invert: unaryfunc, pub nb_lshift: binaryfunc, pub nb_rshift: binaryfunc, pub nb_and: binaryfunc, pub nb_xor: binaryfunc, pub nb_or: binaryfunc, pub nb_int: unaryfunc, pub nb_reserved: *mut ::std::os::raw::c_void, pub nb_float: unaryfunc, pub nb_inplace_add: binaryfunc, pub nb_inplace_subtract: binaryfunc, pub nb_inplace_multiply: binaryfunc, pub nb_inplace_remainder: binaryfunc, pub nb_inplace_power: ternaryfunc, pub nb_inplace_lshift: binaryfunc, pub nb_inplace_rshift: binaryfunc, pub nb_inplace_and: binaryfunc, pub nb_inplace_xor: binaryfunc, pub nb_inplace_or: binaryfunc, pub nb_floor_divide: binaryfunc, pub nb_true_divide: binaryfunc, pub nb_inplace_floor_divide: binaryfunc, pub nb_inplace_true_divide: binaryfunc, pub nb_index: unaryfunc, pub nb_matrix_multiply: binaryfunc, pub nb_inplace_matrix_multiply: binaryfunc, } impl Default for PyNumberMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PySequenceMethods { pub sq_length: lenfunc, pub sq_concat: binaryfunc, pub sq_repeat: ssizeargfunc, pub sq_item: ssizeargfunc, pub was_sq_slice: *mut ::std::os::raw::c_void, pub sq_ass_item: ssizeobjargproc, pub was_sq_ass_slice: *mut ::std::os::raw::c_void, pub sq_contains: objobjproc, pub sq_inplace_concat: binaryfunc, pub sq_inplace_repeat: ssizeargfunc, } impl Default for PySequenceMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyMappingMethods { pub mp_length: lenfunc, pub mp_subscript: binaryfunc, pub mp_ass_subscript: objobjargproc, } impl Default for PyMappingMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type sendfunc = ::std::option::Option< unsafe extern "C" fn( iter: *mut PyObject, value: *mut PyObject, result: *mut *mut PyObject, ) -> PySendResult, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyAsyncMethods { pub am_await: unaryfunc, pub am_aiter: unaryfunc, pub am_anext: unaryfunc, pub am_send: sendfunc, } impl Default for PyAsyncMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyBufferProcs { pub bf_getbuffer: getbufferproc, pub bf_releasebuffer: releasebufferproc, } impl Default for PyBufferProcs { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _typeobject { pub ob_base: PyVarObject, pub tp_name: *const ::std::os::raw::c_char, pub tp_basicsize: Py_ssize_t, pub tp_itemsize: Py_ssize_t, pub tp_dealloc: destructor, pub tp_vectorcall_offset: Py_ssize_t, pub tp_getattr: getattrfunc, pub tp_setattr: setattrfunc, pub tp_as_async: *mut PyAsyncMethods, pub tp_repr: reprfunc, pub tp_as_number: *mut PyNumberMethods, pub tp_as_sequence: *mut PySequenceMethods, pub tp_as_mapping: *mut PyMappingMethods, pub tp_hash: hashfunc, pub tp_call: ternaryfunc, pub tp_str: reprfunc, pub tp_getattro: getattrofunc, pub tp_setattro: setattrofunc, pub tp_as_buffer: *mut PyBufferProcs, pub tp_flags: ::std::os::raw::c_ulong, pub tp_doc: *const ::std::os::raw::c_char, pub tp_traverse: traverseproc, pub tp_clear: inquiry, pub tp_richcompare: richcmpfunc, pub tp_weaklistoffset: Py_ssize_t, pub tp_iter: getiterfunc, pub tp_iternext: iternextfunc, pub tp_methods: *mut PyMethodDef, pub tp_members: *mut PyMemberDef, pub tp_getset: *mut PyGetSetDef, pub tp_base: *mut _typeobject, pub tp_dict: *mut PyObject, pub tp_descr_get: descrgetfunc, pub tp_descr_set: descrsetfunc, pub tp_dictoffset: Py_ssize_t, pub tp_init: initproc, pub tp_alloc: allocfunc, pub tp_new: newfunc, pub tp_free: freefunc, pub tp_is_gc: inquiry, pub tp_bases: *mut PyObject, pub tp_mro: *mut PyObject, pub tp_cache: *mut PyObject, pub tp_subclasses: *mut PyObject, pub tp_weaklist: *mut PyObject, pub tp_del: destructor, pub tp_version_tag: ::std::os::raw::c_uint, pub tp_finalize: destructor, pub tp_vectorcall: vectorcallfunc, } impl Default for _typeobject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyBytesObject { pub ob_base: PyVarObject, pub ob_shash: Py_hash_t, pub ob_sval: [::std::os::raw::c_char; 1usize], } impl Default for PyBytesObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type Py_UCS4 = u32; pub type Py_UCS2 = u16; pub type Py_UCS1 = u8; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyASCIIObject { pub ob_base: PyObject, pub length: Py_ssize_t, pub hash: Py_hash_t, pub state: PyASCIIObject__bindgen_ty_1, pub wstr: *mut wchar_t, } #[repr(C)] #[repr(align(4))] #[derive(Debug, Default, Copy, Clone)] pub struct PyASCIIObject__bindgen_ty_1 { pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u8>, } impl PyASCIIObject__bindgen_ty_1 { #[inline] pub fn interned(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) } } #[inline] pub fn set_interned(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(0usize, 2u8, val as u64) } } #[inline] pub fn kind(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 3u8) as u32) } } #[inline] pub fn set_kind(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(2usize, 3u8, val as u64) } } #[inline] pub fn compact(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } } #[inline] pub fn set_compact(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(5usize, 1u8, val as u64) } } #[inline] pub fn ascii(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } } #[inline] pub fn set_ascii(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(6usize, 1u8, val as u64) } } #[inline] pub fn ready(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } } #[inline] pub fn set_ready(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(7usize, 1u8, val as u64) } } #[inline] pub fn new_bitfield_1( interned: ::std::os::raw::c_uint, kind: ::std::os::raw::c_uint, compact: ::std::os::raw::c_uint, ascii: ::std::os::raw::c_uint, ready: ::std::os::raw::c_uint, ) -> __BindgenBitfieldUnit<[u8; 4usize], u8> { let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u8> = Default::default(); __bindgen_bitfield_unit.set(0usize, 2u8, { let interned: u32 = unsafe { ::std::mem::transmute(interned) }; interned as u64 }); __bindgen_bitfield_unit.set(2usize, 3u8, { let kind: u32 = unsafe { ::std::mem::transmute(kind) }; kind as u64 }); __bindgen_bitfield_unit.set(5usize, 1u8, { let compact: u32 = unsafe { ::std::mem::transmute(compact) }; compact as u64 }); __bindgen_bitfield_unit.set(6usize, 1u8, { let ascii: u32 = unsafe { ::std::mem::transmute(ascii) }; ascii as u64 }); __bindgen_bitfield_unit.set(7usize, 1u8, { let ready: u32 = unsafe { ::std::mem::transmute(ready) }; ready as u64 }); __bindgen_bitfield_unit } } impl Default for PyASCIIObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyCompactUnicodeObject { pub _base: PyASCIIObject, pub utf8_length: Py_ssize_t, pub utf8: *mut ::std::os::raw::c_char, pub wstr_length: Py_ssize_t, } impl Default for PyCompactUnicodeObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct PyUnicodeObject { pub _base: PyCompactUnicodeObject, pub data: PyUnicodeObject__bindgen_ty_1, } #[repr(C)] #[derive(Copy, Clone)] pub union PyUnicodeObject__bindgen_ty_1 { pub any: *mut ::std::os::raw::c_void, pub latin1: *mut Py_UCS1, pub ucs2: *mut Py_UCS2, pub ucs4: *mut Py_UCS4, _bindgen_union_align: u64, } impl Default for PyUnicodeObject__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for PyUnicodeObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyLongObject = _longobject; pub type digit = u32; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _longobject { pub ob_base: PyVarObject, pub ob_digit: [digit; 1usize], } impl Default for _longobject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyFloatObject { pub ob_base: PyObject, pub ob_fval: f64, } impl Default for PyFloatObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyTupleObject { pub ob_base: PyVarObject, pub ob_item: [*mut PyObject; 1usize], } impl Default for PyTupleObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyListObject { pub ob_base: PyVarObject, pub ob_item: *mut *mut PyObject, pub allocated: Py_ssize_t, } impl Default for PyListObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyDictKeysObject = _dictkeysobject; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyDictObject { pub ob_base: PyObject, pub ma_used: Py_ssize_t, pub ma_version_tag: u64, pub ma_keys: *mut PyDictKeysObject, pub ma_values: *mut *mut PyObject, } impl Default for PyDictObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyCFunction = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyMethodDef { pub ml_name: *const ::std::os::raw::c_char, pub ml_meth: PyCFunction, pub ml_flags: ::std::os::raw::c_int, pub ml_doc: *const ::std::os::raw::c_char, } impl Default for PyMethodDef { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type Py_OpenCodeHookFunction = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_void) -> *mut PyObject, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _PyOpcache { _unused: [u8; 0], } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyCodeObject { pub ob_base: PyObject, pub co_argcount: ::std::os::raw::c_int, pub co_posonlyargcount: ::std::os::raw::c_int, pub co_kwonlyargcount: ::std::os::raw::c_int, pub co_nlocals: ::std::os::raw::c_int, pub co_stacksize: ::std::os::raw::c_int, pub co_flags: ::std::os::raw::c_int, pub co_firstlineno: ::std::os::raw::c_int, pub co_code: *mut PyObject, pub co_consts: *mut PyObject, pub co_names: *mut PyObject, pub co_varnames: *mut PyObject, pub co_freevars: *mut PyObject, pub co_cellvars: *mut PyObject, pub co_cell2arg: *mut Py_ssize_t, pub co_filename: *mut PyObject, pub co_name: *mut PyObject, pub co_linetable: *mut PyObject, pub co_zombieframe: *mut ::std::os::raw::c_void, pub co_weakreflist: *mut PyObject, pub co_extra: *mut ::std::os::raw::c_void, pub co_opcache_map: *mut ::std::os::raw::c_uchar, pub co_opcache: *mut _PyOpcache, pub co_opcache_flag: ::std::os::raw::c_int, pub co_opcache_size: ::std::os::raw::c_uchar, } impl Default for PyCodeObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyFrameObject = _frame; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PySliceObject { pub ob_base: PyObject, pub start: *mut PyObject, pub stop: *mut PyObject, pub step: *mut PyObject, } impl Default for PySliceObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyThreadState = _ts; pub type PyInterpreterState = _is; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyWideStringList { pub length: Py_ssize_t, pub items: *mut *mut wchar_t, } impl Default for PyWideStringList { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct PyPreConfig { pub _config_init: ::std::os::raw::c_int, pub parse_argv: ::std::os::raw::c_int, pub isolated: ::std::os::raw::c_int, pub use_environment: ::std::os::raw::c_int, pub configure_locale: ::std::os::raw::c_int, pub coerce_c_locale: ::std::os::raw::c_int, pub coerce_c_locale_warn: ::std::os::raw::c_int, pub utf8_mode: ::std::os::raw::c_int, pub dev_mode: ::std::os::raw::c_int, pub allocator: ::std::os::raw::c_int, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyConfig { pub _config_init: ::std::os::raw::c_int, pub isolated: ::std::os::raw::c_int, pub use_environment: ::std::os::raw::c_int, pub dev_mode: ::std::os::raw::c_int, pub install_signal_handlers: ::std::os::raw::c_int, pub use_hash_seed: ::std::os::raw::c_int, pub hash_seed: ::std::os::raw::c_ulong, pub faulthandler: ::std::os::raw::c_int, pub tracemalloc: ::std::os::raw::c_int, pub import_time: ::std::os::raw::c_int, pub show_ref_count: ::std::os::raw::c_int, pub dump_refs: ::std::os::raw::c_int, pub malloc_stats: ::std::os::raw::c_int, pub filesystem_encoding: *mut wchar_t, pub filesystem_errors: *mut wchar_t, pub pycache_prefix: *mut wchar_t, pub parse_argv: ::std::os::raw::c_int, pub orig_argv: PyWideStringList, pub argv: PyWideStringList, pub xoptions: PyWideStringList, pub warnoptions: PyWideStringList, pub site_import: ::std::os::raw::c_int, pub bytes_warning: ::std::os::raw::c_int, pub warn_default_encoding: ::std::os::raw::c_int, pub inspect: ::std::os::raw::c_int, pub interactive: ::std::os::raw::c_int, pub optimization_level: ::std::os::raw::c_int, pub parser_debug: ::std::os::raw::c_int, pub write_bytecode: ::std::os::raw::c_int, pub verbose: ::std::os::raw::c_int, pub quiet: ::std::os::raw::c_int, pub user_site_directory: ::std::os::raw::c_int, pub configure_c_stdio: ::std::os::raw::c_int, pub buffered_stdio: ::std::os::raw::c_int, pub stdio_encoding: *mut wchar_t, pub stdio_errors: *mut wchar_t, pub check_hash_pycs_mode: *mut wchar_t, pub pathconfig_warnings: ::std::os::raw::c_int, pub program_name: *mut wchar_t, pub pythonpath_env: *mut wchar_t, pub home: *mut wchar_t, pub platlibdir: *mut wchar_t, pub module_search_paths_set: ::std::os::raw::c_int, pub module_search_paths: PyWideStringList, pub executable: *mut wchar_t, pub base_executable: *mut wchar_t, pub prefix: *mut wchar_t, pub base_prefix: *mut wchar_t, pub exec_prefix: *mut wchar_t, pub base_exec_prefix: *mut wchar_t, pub skip_source_first_line: ::std::os::raw::c_int, pub run_command: *mut wchar_t, pub run_module: *mut wchar_t, pub run_filename: *mut wchar_t, pub _install_importlib: ::std::os::raw::c_int, pub _init_main: ::std::os::raw::c_int, pub _isolated_interpreter: ::std::os::raw::c_int, } impl Default for PyConfig { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type Py_tracefunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyFrameObject, arg3: ::std::os::raw::c_int, arg4: *mut PyObject, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _cframe { pub use_tracing: ::std::os::raw::c_int, pub previous: *mut _cframe, } impl Default for _cframe { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type CFrame = _cframe; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _err_stackitem { pub exc_type: *mut PyObject, pub exc_value: *mut PyObject, pub exc_traceback: *mut PyObject, pub previous_item: *mut _err_stackitem, } impl Default for _err_stackitem { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type _PyErr_StackItem = _err_stackitem; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _ts { pub prev: *mut _ts, pub next: *mut _ts, pub interp: *mut PyInterpreterState, pub frame: *mut PyFrameObject, pub recursion_depth: ::std::os::raw::c_int, pub recursion_headroom: ::std::os::raw::c_int, pub stackcheck_counter: ::std::os::raw::c_int, pub tracing: ::std::os::raw::c_int, pub cframe: *mut CFrame, pub c_profilefunc: Py_tracefunc, pub c_tracefunc: Py_tracefunc, pub c_profileobj: *mut PyObject, pub c_traceobj: *mut PyObject, pub curexc_type: *mut PyObject, pub curexc_value: *mut PyObject, pub curexc_traceback: *mut PyObject, pub exc_state: _PyErr_StackItem, pub exc_info: *mut _PyErr_StackItem, pub dict: *mut PyObject, pub gilstate_counter: ::std::os::raw::c_int, pub async_exc: *mut PyObject, pub thread_id: ::std::os::raw::c_ulong, pub trash_delete_nesting: ::std::os::raw::c_int, pub trash_delete_later: *mut PyObject, pub on_delete: ::std::option::Option, pub on_delete_data: *mut ::std::os::raw::c_void, pub coroutine_origin_tracking_depth: ::std::os::raw::c_int, pub async_gen_firstiter: *mut PyObject, pub async_gen_finalizer: *mut PyObject, pub context: *mut PyObject, pub context_ver: u64, pub id: u64, pub root_cframe: CFrame, } impl Default for _ts { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type _PyFrameEvalFunction = ::std::option::Option< unsafe extern "C" fn( tstate: *mut PyThreadState, arg1: *mut PyFrameObject, arg2: ::std::os::raw::c_int, ) -> *mut PyObject, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _xid { pub data: *mut ::std::os::raw::c_void, pub obj: *mut PyObject, pub interp: i64, pub new_object: ::std::option::Option *mut PyObject>, pub free: ::std::option::Option, } impl Default for _xid { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type crossinterpdatafunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut _xid) -> ::std::os::raw::c_int, >; pub type getter = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_void) -> *mut PyObject, >; pub type setter = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyGetSetDef { pub name: *const ::std::os::raw::c_char, pub get: getter, pub set: setter, pub doc: *const ::std::os::raw::c_char, pub closure: *mut ::std::os::raw::c_void, } impl Default for PyGetSetDef { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyMemberDef { _unused: [u8; 0], } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyBaseExceptionObject { pub ob_base: PyObject, pub dict: *mut PyObject, pub args: *mut PyObject, pub traceback: *mut PyObject, pub context: *mut PyObject, pub cause: *mut PyObject, pub suppress_context: ::std::os::raw::c_char, } impl Default for PyBaseExceptionObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyThread_type_lock = *mut ::std::os::raw::c_void; pub type Py_tss_t = _Py_tss_t; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_tss_t { pub _is_initialized: ::std::os::raw::c_int, pub _key: pthread_key_t, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _pycontextobject { _unused: [u8; 0], } pub type PyContext = _pycontextobject; pub type Py_AuditHookFunction = ::std::option::Option< unsafe extern "C" fn( arg1: *const ::std::os::raw::c_char, arg2: *mut PyObject, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; pub const _Py_error_handler__Py_ERROR_UNKNOWN: _Py_error_handler = 0; pub const _Py_error_handler__Py_ERROR_STRICT: _Py_error_handler = 1; pub const _Py_error_handler__Py_ERROR_SURROGATEESCAPE: _Py_error_handler = 2; pub const _Py_error_handler__Py_ERROR_REPLACE: _Py_error_handler = 3; pub const _Py_error_handler__Py_ERROR_IGNORE: _Py_error_handler = 4; pub const _Py_error_handler__Py_ERROR_BACKSLASHREPLACE: _Py_error_handler = 5; pub const _Py_error_handler__Py_ERROR_SURROGATEPASS: _Py_error_handler = 6; pub const _Py_error_handler__Py_ERROR_XMLCHARREFREPLACE: _Py_error_handler = 7; pub const _Py_error_handler__Py_ERROR_OTHER: _Py_error_handler = 8; pub type _Py_error_handler = u32; pub type PyFrameState = ::std::os::raw::c_schar; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct PyTryBlock { pub b_type: ::std::os::raw::c_int, pub b_handler: ::std::os::raw::c_int, pub b_level: ::std::os::raw::c_int, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _frame { pub ob_base: PyVarObject, pub f_back: *mut _frame, pub f_code: *mut PyCodeObject, pub f_builtins: *mut PyObject, pub f_globals: *mut PyObject, pub f_locals: *mut PyObject, pub f_valuestack: *mut *mut PyObject, pub f_trace: *mut PyObject, pub f_stackdepth: ::std::os::raw::c_int, pub f_trace_lines: ::std::os::raw::c_char, pub f_trace_opcodes: ::std::os::raw::c_char, pub f_gen: *mut PyObject, pub f_lasti: ::std::os::raw::c_int, pub f_lineno: ::std::os::raw::c_int, pub f_iblock: ::std::os::raw::c_int, pub f_state: PyFrameState, pub f_blockstack: [PyTryBlock; 20usize], pub f_localsplus: [*mut PyObject; 1usize], } impl Default for _frame { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyDictKeyEntry { pub me_hash: Py_hash_t, pub me_key: *mut PyObject, pub me_value: *mut PyObject, } impl Default for PyDictKeyEntry { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type dict_lookup_func = ::std::option::Option< unsafe extern "C" fn( mp: *mut PyDictObject, key: *mut PyObject, hash: Py_hash_t, value_addr: *mut *mut PyObject, ) -> Py_ssize_t, >; #[repr(C)] #[derive(Debug)] pub struct _dictkeysobject { pub dk_refcnt: Py_ssize_t, pub dk_size: Py_ssize_t, pub dk_lookup: dict_lookup_func, pub dk_usable: Py_ssize_t, pub dk_nentries: Py_ssize_t, pub dk_indices: __IncompleteArrayField<::std::os::raw::c_char>, } impl Default for _dictkeysobject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type atomic_int = u32; pub type atomic_uintptr_t = usize; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_atomic_address { pub _value: atomic_uintptr_t, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_atomic_int { pub _value: atomic_int, } #[repr(C)] #[derive(Copy, Clone)] pub struct _gil_runtime_state { pub interval: ::std::os::raw::c_ulong, pub last_holder: _Py_atomic_address, pub locked: _Py_atomic_int, pub switch_number: ::std::os::raw::c_ulong, pub cond: pthread_cond_t, pub mutex: pthread_mutex_t, pub switch_cond: pthread_cond_t, pub switch_mutex: pthread_mutex_t, } impl Default for _gil_runtime_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _ceval_runtime_state { pub signals_pending: _Py_atomic_int, pub gil: _gil_runtime_state, } impl Default for _ceval_runtime_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _gilstate_runtime_state { pub check_enabled: ::std::os::raw::c_int, pub tstate_current: _Py_atomic_address, pub autoInterpreterState: *mut PyInterpreterState, pub autoTSSkey: Py_tss_t, } impl Default for _gilstate_runtime_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_AuditHookEntry { pub next: *mut _Py_AuditHookEntry, pub hookCFunction: Py_AuditHookFunction, pub userData: *mut ::std::os::raw::c_void, } impl Default for _Py_AuditHookEntry { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_unicode_runtime_ids { pub lock: PyThread_type_lock, pub next_index: Py_ssize_t, } impl Default for _Py_unicode_runtime_ids { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct pyruntimestate { pub preinitializing: ::std::os::raw::c_int, pub preinitialized: ::std::os::raw::c_int, pub core_initialized: ::std::os::raw::c_int, pub initialized: ::std::os::raw::c_int, pub _finalizing: _Py_atomic_address, pub interpreters: pyruntimestate_pyinterpreters, pub xidregistry: pyruntimestate__xidregistry, pub main_thread: ::std::os::raw::c_ulong, pub exitfuncs: [::std::option::Option; 32usize], pub nexitfuncs: ::std::os::raw::c_int, pub ceval: _ceval_runtime_state, pub gilstate: _gilstate_runtime_state, pub preconfig: PyPreConfig, pub open_code_hook: Py_OpenCodeHookFunction, pub open_code_userdata: *mut ::std::os::raw::c_void, pub audit_hook_head: *mut _Py_AuditHookEntry, pub unicode_ids: _Py_unicode_runtime_ids, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct pyruntimestate_pyinterpreters { pub mutex: PyThread_type_lock, pub head: *mut PyInterpreterState, pub main: *mut PyInterpreterState, pub next_id: i64, } impl Default for pyruntimestate_pyinterpreters { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct pyruntimestate__xidregistry { pub mutex: PyThread_type_lock, pub head: *mut _xidregitem, } impl Default for pyruntimestate__xidregistry { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for pyruntimestate { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct ast_state { pub initialized: ::std::os::raw::c_int, pub AST_type: *mut PyObject, pub Add_singleton: *mut PyObject, pub Add_type: *mut PyObject, pub And_singleton: *mut PyObject, pub And_type: *mut PyObject, pub AnnAssign_type: *mut PyObject, pub Assert_type: *mut PyObject, pub Assign_type: *mut PyObject, pub AsyncFor_type: *mut PyObject, pub AsyncFunctionDef_type: *mut PyObject, pub AsyncWith_type: *mut PyObject, pub Attribute_type: *mut PyObject, pub AugAssign_type: *mut PyObject, pub Await_type: *mut PyObject, pub BinOp_type: *mut PyObject, pub BitAnd_singleton: *mut PyObject, pub BitAnd_type: *mut PyObject, pub BitOr_singleton: *mut PyObject, pub BitOr_type: *mut PyObject, pub BitXor_singleton: *mut PyObject, pub BitXor_type: *mut PyObject, pub BoolOp_type: *mut PyObject, pub Break_type: *mut PyObject, pub Call_type: *mut PyObject, pub ClassDef_type: *mut PyObject, pub Compare_type: *mut PyObject, pub Constant_type: *mut PyObject, pub Continue_type: *mut PyObject, pub Del_singleton: *mut PyObject, pub Del_type: *mut PyObject, pub Delete_type: *mut PyObject, pub DictComp_type: *mut PyObject, pub Dict_type: *mut PyObject, pub Div_singleton: *mut PyObject, pub Div_type: *mut PyObject, pub Eq_singleton: *mut PyObject, pub Eq_type: *mut PyObject, pub ExceptHandler_type: *mut PyObject, pub Expr_type: *mut PyObject, pub Expression_type: *mut PyObject, pub FloorDiv_singleton: *mut PyObject, pub FloorDiv_type: *mut PyObject, pub For_type: *mut PyObject, pub FormattedValue_type: *mut PyObject, pub FunctionDef_type: *mut PyObject, pub FunctionType_type: *mut PyObject, pub GeneratorExp_type: *mut PyObject, pub Global_type: *mut PyObject, pub GtE_singleton: *mut PyObject, pub GtE_type: *mut PyObject, pub Gt_singleton: *mut PyObject, pub Gt_type: *mut PyObject, pub IfExp_type: *mut PyObject, pub If_type: *mut PyObject, pub ImportFrom_type: *mut PyObject, pub Import_type: *mut PyObject, pub In_singleton: *mut PyObject, pub In_type: *mut PyObject, pub Interactive_type: *mut PyObject, pub Invert_singleton: *mut PyObject, pub Invert_type: *mut PyObject, pub IsNot_singleton: *mut PyObject, pub IsNot_type: *mut PyObject, pub Is_singleton: *mut PyObject, pub Is_type: *mut PyObject, pub JoinedStr_type: *mut PyObject, pub LShift_singleton: *mut PyObject, pub LShift_type: *mut PyObject, pub Lambda_type: *mut PyObject, pub ListComp_type: *mut PyObject, pub List_type: *mut PyObject, pub Load_singleton: *mut PyObject, pub Load_type: *mut PyObject, pub LtE_singleton: *mut PyObject, pub LtE_type: *mut PyObject, pub Lt_singleton: *mut PyObject, pub Lt_type: *mut PyObject, pub MatMult_singleton: *mut PyObject, pub MatMult_type: *mut PyObject, pub MatchAs_type: *mut PyObject, pub MatchClass_type: *mut PyObject, pub MatchMapping_type: *mut PyObject, pub MatchOr_type: *mut PyObject, pub MatchSequence_type: *mut PyObject, pub MatchSingleton_type: *mut PyObject, pub MatchStar_type: *mut PyObject, pub MatchValue_type: *mut PyObject, pub Match_type: *mut PyObject, pub Mod_singleton: *mut PyObject, pub Mod_type: *mut PyObject, pub Module_type: *mut PyObject, pub Mult_singleton: *mut PyObject, pub Mult_type: *mut PyObject, pub Name_type: *mut PyObject, pub NamedExpr_type: *mut PyObject, pub Nonlocal_type: *mut PyObject, pub NotEq_singleton: *mut PyObject, pub NotEq_type: *mut PyObject, pub NotIn_singleton: *mut PyObject, pub NotIn_type: *mut PyObject, pub Not_singleton: *mut PyObject, pub Not_type: *mut PyObject, pub Or_singleton: *mut PyObject, pub Or_type: *mut PyObject, pub Pass_type: *mut PyObject, pub Pow_singleton: *mut PyObject, pub Pow_type: *mut PyObject, pub RShift_singleton: *mut PyObject, pub RShift_type: *mut PyObject, pub Raise_type: *mut PyObject, pub Return_type: *mut PyObject, pub SetComp_type: *mut PyObject, pub Set_type: *mut PyObject, pub Slice_type: *mut PyObject, pub Starred_type: *mut PyObject, pub Store_singleton: *mut PyObject, pub Store_type: *mut PyObject, pub Sub_singleton: *mut PyObject, pub Sub_type: *mut PyObject, pub Subscript_type: *mut PyObject, pub Try_type: *mut PyObject, pub Tuple_type: *mut PyObject, pub TypeIgnore_type: *mut PyObject, pub UAdd_singleton: *mut PyObject, pub UAdd_type: *mut PyObject, pub USub_singleton: *mut PyObject, pub USub_type: *mut PyObject, pub UnaryOp_type: *mut PyObject, pub While_type: *mut PyObject, pub With_type: *mut PyObject, pub YieldFrom_type: *mut PyObject, pub Yield_type: *mut PyObject, pub __dict__: *mut PyObject, pub __doc__: *mut PyObject, pub __match_args__: *mut PyObject, pub __module__: *mut PyObject, pub _attributes: *mut PyObject, pub _fields: *mut PyObject, pub alias_type: *mut PyObject, pub annotation: *mut PyObject, pub arg: *mut PyObject, pub arg_type: *mut PyObject, pub args: *mut PyObject, pub argtypes: *mut PyObject, pub arguments_type: *mut PyObject, pub asname: *mut PyObject, pub ast: *mut PyObject, pub attr: *mut PyObject, pub bases: *mut PyObject, pub body: *mut PyObject, pub boolop_type: *mut PyObject, pub cases: *mut PyObject, pub cause: *mut PyObject, pub cls: *mut PyObject, pub cmpop_type: *mut PyObject, pub col_offset: *mut PyObject, pub comparators: *mut PyObject, pub comprehension_type: *mut PyObject, pub context_expr: *mut PyObject, pub conversion: *mut PyObject, pub ctx: *mut PyObject, pub decorator_list: *mut PyObject, pub defaults: *mut PyObject, pub elt: *mut PyObject, pub elts: *mut PyObject, pub end_col_offset: *mut PyObject, pub end_lineno: *mut PyObject, pub exc: *mut PyObject, pub excepthandler_type: *mut PyObject, pub expr_context_type: *mut PyObject, pub expr_type: *mut PyObject, pub finalbody: *mut PyObject, pub format_spec: *mut PyObject, pub func: *mut PyObject, pub generators: *mut PyObject, pub guard: *mut PyObject, pub handlers: *mut PyObject, pub id: *mut PyObject, pub ifs: *mut PyObject, pub is_async: *mut PyObject, pub items: *mut PyObject, pub iter: *mut PyObject, pub key: *mut PyObject, pub keys: *mut PyObject, pub keyword_type: *mut PyObject, pub keywords: *mut PyObject, pub kind: *mut PyObject, pub kw_defaults: *mut PyObject, pub kwarg: *mut PyObject, pub kwd_attrs: *mut PyObject, pub kwd_patterns: *mut PyObject, pub kwonlyargs: *mut PyObject, pub left: *mut PyObject, pub level: *mut PyObject, pub lineno: *mut PyObject, pub lower: *mut PyObject, pub match_case_type: *mut PyObject, pub mod_type: *mut PyObject, pub module: *mut PyObject, pub msg: *mut PyObject, pub name: *mut PyObject, pub names: *mut PyObject, pub op: *mut PyObject, pub operand: *mut PyObject, pub operator_type: *mut PyObject, pub ops: *mut PyObject, pub optional_vars: *mut PyObject, pub orelse: *mut PyObject, pub pattern: *mut PyObject, pub pattern_type: *mut PyObject, pub patterns: *mut PyObject, pub posonlyargs: *mut PyObject, pub rest: *mut PyObject, pub returns: *mut PyObject, pub right: *mut PyObject, pub simple: *mut PyObject, pub slice: *mut PyObject, pub step: *mut PyObject, pub stmt_type: *mut PyObject, pub subject: *mut PyObject, pub tag: *mut PyObject, pub target: *mut PyObject, pub targets: *mut PyObject, pub test: *mut PyObject, pub type_: *mut PyObject, pub type_comment: *mut PyObject, pub type_ignore_type: *mut PyObject, pub type_ignores: *mut PyObject, pub unaryop_type: *mut PyObject, pub upper: *mut PyObject, pub value: *mut PyObject, pub values: *mut PyObject, pub vararg: *mut PyObject, pub withitem_type: *mut PyObject, } impl Default for ast_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct PyGC_Head { pub _gc_next: usize, pub _gc_prev: usize, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct gc_generation { pub head: PyGC_Head, pub threshold: ::std::os::raw::c_int, pub count: ::std::os::raw::c_int, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct gc_generation_stats { pub collections: Py_ssize_t, pub collected: Py_ssize_t, pub uncollectable: Py_ssize_t, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _gc_runtime_state { pub trash_delete_later: *mut PyObject, pub trash_delete_nesting: ::std::os::raw::c_int, pub enabled: ::std::os::raw::c_int, pub debug: ::std::os::raw::c_int, pub generations: [gc_generation; 3usize], pub generation0: *mut PyGC_Head, pub permanent_generation: gc_generation, pub generation_stats: [gc_generation_stats; 3usize], pub collecting: ::std::os::raw::c_int, pub garbage: *mut PyObject, pub callbacks: *mut PyObject, pub long_lived_total: Py_ssize_t, pub long_lived_pending: Py_ssize_t, } impl Default for _gc_runtime_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _warnings_runtime_state { pub filters: *mut PyObject, pub once_registry: *mut PyObject, pub default_action: *mut PyObject, pub filters_version: ::std::os::raw::c_long, } impl Default for _warnings_runtime_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _pending_calls { pub lock: PyThread_type_lock, pub calls_to_do: _Py_atomic_int, pub async_exc: ::std::os::raw::c_int, pub calls: [_pending_calls__bindgen_ty_1; 32usize], pub first: ::std::os::raw::c_int, pub last: ::std::os::raw::c_int, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _pending_calls__bindgen_ty_1 { pub func: ::std::option::Option< unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, >, pub arg: *mut ::std::os::raw::c_void, } impl Default for _pending_calls__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for _pending_calls { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _ceval_state { pub recursion_limit: ::std::os::raw::c_int, pub eval_breaker: _Py_atomic_int, pub gil_drop_request: _Py_atomic_int, pub pending: _pending_calls, } impl Default for _ceval_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_unicode_fs_codec { pub encoding: *mut ::std::os::raw::c_char, pub utf8: ::std::os::raw::c_int, pub errors: *mut ::std::os::raw::c_char, pub error_handler: _Py_error_handler, } impl Default for _Py_unicode_fs_codec { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_bytes_state { pub empty_string: *mut PyObject, pub characters: [*mut PyBytesObject; 256usize], } impl Default for _Py_bytes_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_unicode_ids { pub size: Py_ssize_t, pub array: *mut *mut PyObject, } impl Default for _Py_unicode_ids { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_unicode_state { pub empty_string: *mut PyObject, pub latin1: [*mut PyObject; 256usize], pub fs_codec: _Py_unicode_fs_codec, pub interned: *mut PyObject, pub ids: _Py_unicode_ids, } impl Default for _Py_unicode_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_float_state { pub numfree: ::std::os::raw::c_int, pub free_list: *mut PyFloatObject, } impl Default for _Py_float_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_tuple_state { pub free_list: [*mut PyTupleObject; 20usize], pub numfree: [::std::os::raw::c_int; 20usize], } impl Default for _Py_tuple_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_list_state { pub free_list: [*mut PyListObject; 80usize], pub numfree: ::std::os::raw::c_int, } impl Default for _Py_list_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_dict_state { pub free_list: [*mut PyDictObject; 80usize], pub numfree: ::std::os::raw::c_int, pub keys_free_list: [*mut PyDictKeysObject; 80usize], pub keys_numfree: ::std::os::raw::c_int, } impl Default for _Py_dict_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_frame_state { pub free_list: *mut PyFrameObject, pub numfree: ::std::os::raw::c_int, } impl Default for _Py_frame_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_async_gen_state { pub value_freelist: [*mut _PyAsyncGenWrappedValue; 80usize], pub value_numfree: ::std::os::raw::c_int, pub asend_freelist: [*mut PyAsyncGenASend; 80usize], pub asend_numfree: ::std::os::raw::c_int, } impl Default for _Py_async_gen_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_context_state { pub freelist: *mut PyContext, pub numfree: ::std::os::raw::c_int, } impl Default for _Py_context_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_exc_state { pub errnomap: *mut PyObject, pub memerrors_freelist: *mut PyBaseExceptionObject, pub memerrors_numfree: ::std::os::raw::c_int, } impl Default for _Py_exc_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct atexit_callback { pub func: *mut PyObject, pub args: *mut PyObject, pub kwargs: *mut PyObject, } impl Default for atexit_callback { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct atexit_state { pub callbacks: *mut *mut atexit_callback, pub ncallbacks: ::std::os::raw::c_int, pub callback_len: ::std::os::raw::c_int, } impl Default for atexit_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct type_cache_entry { pub version: ::std::os::raw::c_uint, pub name: *mut PyObject, pub value: *mut PyObject, } impl Default for type_cache_entry { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct type_cache { pub hashtable: [type_cache_entry; 4096usize], } impl Default for type_cache { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _is { pub next: *mut _is, pub tstate_head: *mut _ts, pub runtime: *mut pyruntimestate, pub id: i64, pub id_refcount: i64, pub requires_idref: ::std::os::raw::c_int, pub id_mutex: PyThread_type_lock, pub finalizing: ::std::os::raw::c_int, pub ceval: _ceval_state, pub gc: _gc_runtime_state, pub modules: *mut PyObject, pub modules_by_index: *mut PyObject, pub sysdict: *mut PyObject, pub builtins: *mut PyObject, pub importlib: *mut PyObject, pub num_threads: ::std::os::raw::c_long, pub pythread_stacksize: usize, pub codec_search_path: *mut PyObject, pub codec_search_cache: *mut PyObject, pub codec_error_registry: *mut PyObject, pub codecs_initialized: ::std::os::raw::c_int, pub config: PyConfig, pub dlopenflags: ::std::os::raw::c_int, pub dict: *mut PyObject, pub builtins_copy: *mut PyObject, pub import_func: *mut PyObject, pub eval_frame: _PyFrameEvalFunction, pub co_extra_user_count: Py_ssize_t, pub co_extra_freefuncs: [freefunc; 255usize], pub before_forkers: *mut PyObject, pub after_forkers_parent: *mut PyObject, pub after_forkers_child: *mut PyObject, pub tstate_next_unique_id: u64, pub warnings: _warnings_runtime_state, pub atexit: atexit_state, pub audit_hooks: *mut PyObject, pub small_ints: [*mut PyLongObject; 262usize], pub bytes: _Py_bytes_state, pub unicode: _Py_unicode_state, pub float_state: _Py_float_state, pub slice_cache: *mut PySliceObject, pub tuple: _Py_tuple_state, pub list: _Py_list_state, pub dict_state: _Py_dict_state, pub frame: _Py_frame_state, pub async_gen: _Py_async_gen_state, pub context: _Py_context_state, pub exc_state: _Py_exc_state, pub ast: ast_state, pub type_cache: type_cache, } impl Default for _is { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _xidregitem { pub cls: *mut PyTypeObject, pub getdata: crossinterpdatafunc, pub next: *mut _xidregitem, } impl Default for _xidregitem { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _PyAsyncGenWrappedValue { pub _address: u8, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct PyAsyncGenASend { pub _address: u8, } ================================================ FILE: src/python_bindings/v3_11_0.rs ================================================ // Generated bindings for python v3.11.0 #![allow(dead_code)] #![allow(non_upper_case_globals)] #![allow(non_camel_case_types)] #![allow(non_snake_case)] #![allow(clippy::useless_transmute)] #![allow(clippy::default_trait_access)] #![allow(clippy::cast_lossless)] #![allow(clippy::trivially_copy_pass_by_ref)] #![allow(clippy::upper_case_acronyms)] #![allow(clippy::too_many_arguments)] /* automatically generated by rust-bindgen 0.72.0 */ #[repr(C)] #[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] pub struct __BindgenBitfieldUnit { storage: Storage, } impl __BindgenBitfieldUnit { #[inline] pub const fn new(storage: Storage) -> Self { Self { storage } } } impl __BindgenBitfieldUnit where Storage: AsRef<[u8]> + AsMut<[u8]>, { #[inline] fn extract_bit(byte: u8, index: usize) -> bool { let bit_index = if cfg!(target_endian = "big") { 7 - (index % 8) } else { index % 8 }; let mask = 1 << bit_index; byte & mask == mask } #[inline] pub fn get_bit(&self, index: usize) -> bool { debug_assert!(index / 8 < self.storage.as_ref().len()); let byte_index = index / 8; let byte = self.storage.as_ref()[byte_index]; Self::extract_bit(byte, index) } #[inline] pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { debug_assert!(index / 8 < core::mem::size_of::()); let byte_index = index / 8; let byte = unsafe { *(core::ptr::addr_of!((*this).storage) as *const u8).add(byte_index) }; Self::extract_bit(byte, index) } #[inline] fn change_bit(byte: u8, index: usize, val: bool) -> u8 { let bit_index = if cfg!(target_endian = "big") { 7 - (index % 8) } else { index % 8 }; let mask = 1 << bit_index; if val { byte | mask } else { byte & !mask } } #[inline] pub fn set_bit(&mut self, index: usize, val: bool) { debug_assert!(index / 8 < self.storage.as_ref().len()); let byte_index = index / 8; let byte = &mut self.storage.as_mut()[byte_index]; *byte = Self::change_bit(*byte, index, val); } #[inline] pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { debug_assert!(index / 8 < core::mem::size_of::()); let byte_index = index / 8; let byte = unsafe { (core::ptr::addr_of_mut!((*this).storage) as *mut u8).add(byte_index) }; unsafe { *byte = Self::change_bit(*byte, index, val) }; } #[inline] pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); let mut val = 0; for i in 0..(bit_width as usize) { if self.get_bit(i + bit_offset) { let index = if cfg!(target_endian = "big") { bit_width as usize - 1 - i } else { i }; val |= 1 << index; } } val } #[inline] pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::()); let mut val = 0; for i in 0..(bit_width as usize) { if unsafe { Self::raw_get_bit(this, i + bit_offset) } { let index = if cfg!(target_endian = "big") { bit_width as usize - 1 - i } else { i }; val |= 1 << index; } } val } #[inline] pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); for i in 0..(bit_width as usize) { let mask = 1 << i; let val_bit_is_set = val & mask == mask; let index = if cfg!(target_endian = "big") { bit_width as usize - 1 - i } else { i }; self.set_bit(index + bit_offset, val_bit_is_set); } } #[inline] pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::()); for i in 0..(bit_width as usize) { let mask = 1 << i; let val_bit_is_set = val & mask == mask; let index = if cfg!(target_endian = "big") { bit_width as usize - 1 - i } else { i }; unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; } } } #[repr(C)] #[derive(Default)] pub struct __IncompleteArrayField(::std::marker::PhantomData, [T; 0]); impl __IncompleteArrayField { #[inline] pub const fn new() -> Self { __IncompleteArrayField(::std::marker::PhantomData, []) } #[inline] pub fn as_ptr(&self) -> *const T { self as *const _ as *const T } #[inline] pub fn as_mut_ptr(&mut self) -> *mut T { self as *mut _ as *mut T } #[inline] pub unsafe fn as_slice(&self, len: usize) -> &[T] { ::std::slice::from_raw_parts(self.as_ptr(), len) } #[inline] pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] { ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len) } } impl ::std::fmt::Debug for __IncompleteArrayField { fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { fmt.write_str("__IncompleteArrayField") } } pub type wchar_t = ::std::os::raw::c_int; pub type Py_ssize_t = isize; pub type Py_hash_t = Py_ssize_t; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyMemberDef { _unused: [u8; 0], } pub type PyObject = _object; pub type PyLongObject = _longobject; pub type PyTypeObject = _typeobject; pub type PyFrameObject = _frame; pub type PyThreadState = _ts; pub type PyInterpreterState = _is; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct Py_buffer { pub buf: *mut ::std::os::raw::c_void, pub obj: *mut PyObject, pub len: Py_ssize_t, pub itemsize: Py_ssize_t, pub readonly: ::std::os::raw::c_int, pub ndim: ::std::os::raw::c_int, pub format: *mut ::std::os::raw::c_char, pub shape: *mut Py_ssize_t, pub strides: *mut Py_ssize_t, pub suboffsets: *mut Py_ssize_t, pub internal: *mut ::std::os::raw::c_void, } impl Default for Py_buffer { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _object { pub ob_refcnt: Py_ssize_t, pub ob_type: *mut PyTypeObject, } impl Default for _object { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyVarObject { pub ob_base: PyObject, pub ob_size: Py_ssize_t, } impl Default for PyVarObject { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type unaryfunc = ::std::option::Option *mut PyObject>; pub type binaryfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject, >; pub type ternaryfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> *mut PyObject, >; pub type inquiry = ::std::option::Option ::std::os::raw::c_int>; pub type lenfunc = ::std::option::Option Py_ssize_t>; pub type ssizeargfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: Py_ssize_t) -> *mut PyObject, >; pub type ssizeobjargproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: Py_ssize_t, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type objobjargproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type objobjproc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> ::std::os::raw::c_int, >; pub type visitproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; pub type traverseproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: visitproc, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; pub type freefunc = ::std::option::Option; pub type destructor = ::std::option::Option; pub type getattrfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_char) -> *mut PyObject, >; pub type getattrofunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject, >; pub type setattrfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_char, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type setattrofunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type reprfunc = ::std::option::Option *mut PyObject>; pub type hashfunc = ::std::option::Option Py_hash_t>; pub type richcmpfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: ::std::os::raw::c_int, ) -> *mut PyObject, >; pub type getiterfunc = ::std::option::Option *mut PyObject>; pub type iternextfunc = ::std::option::Option *mut PyObject>; pub type descrgetfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> *mut PyObject, >; pub type descrsetfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type initproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type newfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyTypeObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> *mut PyObject, >; pub type allocfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyTypeObject, arg2: Py_ssize_t) -> *mut PyObject, >; pub const PySendResult_PYGEN_RETURN: PySendResult = 0; pub const PySendResult_PYGEN_ERROR: PySendResult = -1; pub const PySendResult_PYGEN_NEXT: PySendResult = 1; pub type PySendResult = ::std::os::raw::c_int; pub type getbufferproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut Py_buffer, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >; pub type releasebufferproc = ::std::option::Option; pub type vectorcallfunc = ::std::option::Option< unsafe extern "C" fn( callable: *mut PyObject, args: *const *mut PyObject, nargsf: usize, kwnames: *mut PyObject, ) -> *mut PyObject, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyNumberMethods { pub nb_add: binaryfunc, pub nb_subtract: binaryfunc, pub nb_multiply: binaryfunc, pub nb_remainder: binaryfunc, pub nb_divmod: binaryfunc, pub nb_power: ternaryfunc, pub nb_negative: unaryfunc, pub nb_positive: unaryfunc, pub nb_absolute: unaryfunc, pub nb_bool: inquiry, pub nb_invert: unaryfunc, pub nb_lshift: binaryfunc, pub nb_rshift: binaryfunc, pub nb_and: binaryfunc, pub nb_xor: binaryfunc, pub nb_or: binaryfunc, pub nb_int: unaryfunc, pub nb_reserved: *mut ::std::os::raw::c_void, pub nb_float: unaryfunc, pub nb_inplace_add: binaryfunc, pub nb_inplace_subtract: binaryfunc, pub nb_inplace_multiply: binaryfunc, pub nb_inplace_remainder: binaryfunc, pub nb_inplace_power: ternaryfunc, pub nb_inplace_lshift: binaryfunc, pub nb_inplace_rshift: binaryfunc, pub nb_inplace_and: binaryfunc, pub nb_inplace_xor: binaryfunc, pub nb_inplace_or: binaryfunc, pub nb_floor_divide: binaryfunc, pub nb_true_divide: binaryfunc, pub nb_inplace_floor_divide: binaryfunc, pub nb_inplace_true_divide: binaryfunc, pub nb_index: unaryfunc, pub nb_matrix_multiply: binaryfunc, pub nb_inplace_matrix_multiply: binaryfunc, } impl Default for PyNumberMethods { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PySequenceMethods { pub sq_length: lenfunc, pub sq_concat: binaryfunc, pub sq_repeat: ssizeargfunc, pub sq_item: ssizeargfunc, pub was_sq_slice: *mut ::std::os::raw::c_void, pub sq_ass_item: ssizeobjargproc, pub was_sq_ass_slice: *mut ::std::os::raw::c_void, pub sq_contains: objobjproc, pub sq_inplace_concat: binaryfunc, pub sq_inplace_repeat: ssizeargfunc, } impl Default for PySequenceMethods { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct PyMappingMethods { pub mp_length: lenfunc, pub mp_subscript: binaryfunc, pub mp_ass_subscript: objobjargproc, } pub type sendfunc = ::std::option::Option< unsafe extern "C" fn( iter: *mut PyObject, value: *mut PyObject, result: *mut *mut PyObject, ) -> PySendResult, >; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct PyAsyncMethods { pub am_await: unaryfunc, pub am_aiter: unaryfunc, pub am_anext: unaryfunc, pub am_send: sendfunc, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct PyBufferProcs { pub bf_getbuffer: getbufferproc, pub bf_releasebuffer: releasebufferproc, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _typeobject { pub ob_base: PyVarObject, pub tp_name: *const ::std::os::raw::c_char, pub tp_basicsize: Py_ssize_t, pub tp_itemsize: Py_ssize_t, pub tp_dealloc: destructor, pub tp_vectorcall_offset: Py_ssize_t, pub tp_getattr: getattrfunc, pub tp_setattr: setattrfunc, pub tp_as_async: *mut PyAsyncMethods, pub tp_repr: reprfunc, pub tp_as_number: *mut PyNumberMethods, pub tp_as_sequence: *mut PySequenceMethods, pub tp_as_mapping: *mut PyMappingMethods, pub tp_hash: hashfunc, pub tp_call: ternaryfunc, pub tp_str: reprfunc, pub tp_getattro: getattrofunc, pub tp_setattro: setattrofunc, pub tp_as_buffer: *mut PyBufferProcs, pub tp_flags: ::std::os::raw::c_ulong, pub tp_doc: *const ::std::os::raw::c_char, pub tp_traverse: traverseproc, pub tp_clear: inquiry, pub tp_richcompare: richcmpfunc, pub tp_weaklistoffset: Py_ssize_t, pub tp_iter: getiterfunc, pub tp_iternext: iternextfunc, pub tp_methods: *mut PyMethodDef, pub tp_members: *mut PyMemberDef, pub tp_getset: *mut PyGetSetDef, pub tp_base: *mut PyTypeObject, pub tp_dict: *mut PyObject, pub tp_descr_get: descrgetfunc, pub tp_descr_set: descrsetfunc, pub tp_dictoffset: Py_ssize_t, pub tp_init: initproc, pub tp_alloc: allocfunc, pub tp_new: newfunc, pub tp_free: freefunc, pub tp_is_gc: inquiry, pub tp_bases: *mut PyObject, pub tp_mro: *mut PyObject, pub tp_cache: *mut PyObject, pub tp_subclasses: *mut PyObject, pub tp_weaklist: *mut PyObject, pub tp_del: destructor, pub tp_version_tag: ::std::os::raw::c_uint, pub tp_finalize: destructor, pub tp_vectorcall: vectorcallfunc, } impl Default for _typeobject { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _specialization_cache { pub getitem: *mut PyObject, } impl Default for _specialization_cache { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _heaptypeobject { pub ht_type: PyTypeObject, pub as_async: PyAsyncMethods, pub as_number: PyNumberMethods, pub as_mapping: PyMappingMethods, pub as_sequence: PySequenceMethods, pub as_buffer: PyBufferProcs, pub ht_name: *mut PyObject, pub ht_slots: *mut PyObject, pub ht_qualname: *mut PyObject, pub ht_cached_keys: *mut _dictkeysobject, pub ht_module: *mut PyObject, pub _ht_tpname: *mut ::std::os::raw::c_char, pub _spec_cache: _specialization_cache, } impl Default for _heaptypeobject { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type PyHeapTypeObject = _heaptypeobject; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyBytesObject { pub ob_base: PyVarObject, pub ob_shash: Py_hash_t, pub ob_sval: [::std::os::raw::c_char; 1usize], } impl Default for PyBytesObject { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type Py_UCS4 = u32; pub type Py_UCS2 = u16; pub type Py_UCS1 = u8; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyASCIIObject { pub ob_base: PyObject, pub length: Py_ssize_t, pub hash: Py_hash_t, pub state: PyASCIIObject__bindgen_ty_1, pub wstr: *mut wchar_t, } #[repr(C)] #[repr(align(4))] #[derive(Debug, Default, Copy, Clone)] pub struct PyASCIIObject__bindgen_ty_1 { pub _bitfield_align_1: [u8; 0], pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, } impl PyASCIIObject__bindgen_ty_1 { #[inline] pub fn interned(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) } } #[inline] pub fn set_interned(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(0usize, 2u8, val as u64) } } #[inline] pub unsafe fn interned_raw(this: *const Self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( ::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 2u8, ) as u32) } } #[inline] pub unsafe fn set_interned_raw(this: *mut Self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( ::std::ptr::addr_of_mut!((*this)._bitfield_1), 0usize, 2u8, val as u64, ) } } #[inline] pub fn kind(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 3u8) as u32) } } #[inline] pub fn set_kind(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(2usize, 3u8, val as u64) } } #[inline] pub unsafe fn kind_raw(this: *const Self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( ::std::ptr::addr_of!((*this)._bitfield_1), 2usize, 3u8, ) as u32) } } #[inline] pub unsafe fn set_kind_raw(this: *mut Self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( ::std::ptr::addr_of_mut!((*this)._bitfield_1), 2usize, 3u8, val as u64, ) } } #[inline] pub fn compact(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } } #[inline] pub fn set_compact(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(5usize, 1u8, val as u64) } } #[inline] pub unsafe fn compact_raw(this: *const Self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( ::std::ptr::addr_of!((*this)._bitfield_1), 5usize, 1u8, ) as u32) } } #[inline] pub unsafe fn set_compact_raw(this: *mut Self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( ::std::ptr::addr_of_mut!((*this)._bitfield_1), 5usize, 1u8, val as u64, ) } } #[inline] pub fn ascii(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } } #[inline] pub fn set_ascii(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(6usize, 1u8, val as u64) } } #[inline] pub unsafe fn ascii_raw(this: *const Self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( ::std::ptr::addr_of!((*this)._bitfield_1), 6usize, 1u8, ) as u32) } } #[inline] pub unsafe fn set_ascii_raw(this: *mut Self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( ::std::ptr::addr_of_mut!((*this)._bitfield_1), 6usize, 1u8, val as u64, ) } } #[inline] pub fn ready(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } } #[inline] pub fn set_ready(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(7usize, 1u8, val as u64) } } #[inline] pub unsafe fn ready_raw(this: *const Self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( ::std::ptr::addr_of!((*this)._bitfield_1), 7usize, 1u8, ) as u32) } } #[inline] pub unsafe fn set_ready_raw(this: *mut Self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( ::std::ptr::addr_of_mut!((*this)._bitfield_1), 7usize, 1u8, val as u64, ) } } #[inline] pub fn new_bitfield_1( interned: ::std::os::raw::c_uint, kind: ::std::os::raw::c_uint, compact: ::std::os::raw::c_uint, ascii: ::std::os::raw::c_uint, ready: ::std::os::raw::c_uint, ) -> __BindgenBitfieldUnit<[u8; 4usize]> { let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); __bindgen_bitfield_unit.set(0usize, 2u8, { let interned: u32 = unsafe { ::std::mem::transmute(interned) }; interned as u64 }); __bindgen_bitfield_unit.set(2usize, 3u8, { let kind: u32 = unsafe { ::std::mem::transmute(kind) }; kind as u64 }); __bindgen_bitfield_unit.set(5usize, 1u8, { let compact: u32 = unsafe { ::std::mem::transmute(compact) }; compact as u64 }); __bindgen_bitfield_unit.set(6usize, 1u8, { let ascii: u32 = unsafe { ::std::mem::transmute(ascii) }; ascii as u64 }); __bindgen_bitfield_unit.set(7usize, 1u8, { let ready: u32 = unsafe { ::std::mem::transmute(ready) }; ready as u64 }); __bindgen_bitfield_unit } } impl Default for PyASCIIObject { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyCompactUnicodeObject { pub _base: PyASCIIObject, pub utf8_length: Py_ssize_t, pub utf8: *mut ::std::os::raw::c_char, pub wstr_length: Py_ssize_t, } impl Default for PyCompactUnicodeObject { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct PyUnicodeObject { pub _base: PyCompactUnicodeObject, pub data: PyUnicodeObject__bindgen_ty_1, } #[repr(C)] #[derive(Copy, Clone)] pub union PyUnicodeObject__bindgen_ty_1 { pub any: *mut ::std::os::raw::c_void, pub latin1: *mut Py_UCS1, pub ucs2: *mut Py_UCS2, pub ucs4: *mut Py_UCS4, } impl Default for PyUnicodeObject__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } impl Default for PyUnicodeObject { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type digit = u32; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _longobject { pub ob_base: PyVarObject, pub ob_digit: [digit; 1usize], } impl Default for _longobject { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyFloatObject { pub ob_base: PyObject, pub ob_fval: f64, } impl Default for PyFloatObject { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyTupleObject { pub ob_base: PyVarObject, pub ob_item: [*mut PyObject; 1usize], } impl Default for PyTupleObject { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyListObject { pub ob_base: PyVarObject, pub ob_item: *mut *mut PyObject, pub allocated: Py_ssize_t, } impl Default for PyListObject { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type PyDictKeysObject = _dictkeysobject; pub type PyDictValues = _dictvalues; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyDictObject { pub ob_base: PyObject, pub ma_used: Py_ssize_t, pub ma_version_tag: u64, pub ma_keys: *mut PyDictKeysObject, pub ma_values: *mut PyDictValues, } impl Default for PyDictObject { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type PyCFunction = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyMethodDef { pub ml_name: *const ::std::os::raw::c_char, pub ml_meth: PyCFunction, pub ml_flags: ::std::os::raw::c_int, pub ml_doc: *const ::std::os::raw::c_char, } impl Default for PyMethodDef { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyFunctionObject { pub ob_base: PyObject, pub func_globals: *mut PyObject, pub func_builtins: *mut PyObject, pub func_name: *mut PyObject, pub func_qualname: *mut PyObject, pub func_code: *mut PyObject, pub func_defaults: *mut PyObject, pub func_kwdefaults: *mut PyObject, pub func_closure: *mut PyObject, pub func_doc: *mut PyObject, pub func_dict: *mut PyObject, pub func_weakreflist: *mut PyObject, pub func_module: *mut PyObject, pub func_annotations: *mut PyObject, pub vectorcall: vectorcallfunc, pub func_version: u32, } impl Default for PyFunctionObject { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type _Py_CODEUNIT = u16; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyCodeObject { pub ob_base: PyVarObject, pub co_consts: *mut PyObject, pub co_names: *mut PyObject, pub co_exceptiontable: *mut PyObject, pub co_flags: ::std::os::raw::c_int, pub co_warmup: ::std::os::raw::c_short, pub _co_linearray_entry_size: ::std::os::raw::c_short, pub co_argcount: ::std::os::raw::c_int, pub co_posonlyargcount: ::std::os::raw::c_int, pub co_kwonlyargcount: ::std::os::raw::c_int, pub co_stacksize: ::std::os::raw::c_int, pub co_firstlineno: ::std::os::raw::c_int, pub co_nlocalsplus: ::std::os::raw::c_int, pub co_nlocals: ::std::os::raw::c_int, pub co_nplaincellvars: ::std::os::raw::c_int, pub co_ncellvars: ::std::os::raw::c_int, pub co_nfreevars: ::std::os::raw::c_int, pub co_localsplusnames: *mut PyObject, pub co_localspluskinds: *mut PyObject, pub co_filename: *mut PyObject, pub co_name: *mut PyObject, pub co_qualname: *mut PyObject, pub co_linetable: *mut PyObject, pub co_weakreflist: *mut PyObject, pub _co_code: *mut PyObject, pub _co_linearray: *mut ::std::os::raw::c_char, pub _co_firsttraceable: ::std::os::raw::c_int, pub co_extra: *mut ::std::os::raw::c_void, pub co_code_adaptive: [::std::os::raw::c_char; 1usize], } impl Default for PyCodeObject { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _opaque { pub computed_line: ::std::os::raw::c_int, pub lo_next: *const u8, pub limit: *const u8, } impl Default for _opaque { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _line_offsets { pub ar_start: ::std::os::raw::c_int, pub ar_end: ::std::os::raw::c_int, pub ar_line: ::std::os::raw::c_int, pub opaque: _opaque, } impl Default for _line_offsets { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type PyCodeAddressRange = _line_offsets; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PySliceObject { pub ob_base: PyObject, pub start: *mut PyObject, pub stop: *mut PyObject, pub step: *mut PyObject, } impl Default for PySliceObject { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyWideStringList { pub length: Py_ssize_t, pub items: *mut *mut wchar_t, } impl Default for PyWideStringList { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyConfig { pub _config_init: ::std::os::raw::c_int, pub isolated: ::std::os::raw::c_int, pub use_environment: ::std::os::raw::c_int, pub dev_mode: ::std::os::raw::c_int, pub install_signal_handlers: ::std::os::raw::c_int, pub use_hash_seed: ::std::os::raw::c_int, pub hash_seed: ::std::os::raw::c_ulong, pub faulthandler: ::std::os::raw::c_int, pub tracemalloc: ::std::os::raw::c_int, pub import_time: ::std::os::raw::c_int, pub code_debug_ranges: ::std::os::raw::c_int, pub show_ref_count: ::std::os::raw::c_int, pub dump_refs: ::std::os::raw::c_int, pub dump_refs_file: *mut wchar_t, pub malloc_stats: ::std::os::raw::c_int, pub filesystem_encoding: *mut wchar_t, pub filesystem_errors: *mut wchar_t, pub pycache_prefix: *mut wchar_t, pub parse_argv: ::std::os::raw::c_int, pub orig_argv: PyWideStringList, pub argv: PyWideStringList, pub xoptions: PyWideStringList, pub warnoptions: PyWideStringList, pub site_import: ::std::os::raw::c_int, pub bytes_warning: ::std::os::raw::c_int, pub warn_default_encoding: ::std::os::raw::c_int, pub inspect: ::std::os::raw::c_int, pub interactive: ::std::os::raw::c_int, pub optimization_level: ::std::os::raw::c_int, pub parser_debug: ::std::os::raw::c_int, pub write_bytecode: ::std::os::raw::c_int, pub verbose: ::std::os::raw::c_int, pub quiet: ::std::os::raw::c_int, pub user_site_directory: ::std::os::raw::c_int, pub configure_c_stdio: ::std::os::raw::c_int, pub buffered_stdio: ::std::os::raw::c_int, pub stdio_encoding: *mut wchar_t, pub stdio_errors: *mut wchar_t, pub check_hash_pycs_mode: *mut wchar_t, pub use_frozen_modules: ::std::os::raw::c_int, pub safe_path: ::std::os::raw::c_int, pub pathconfig_warnings: ::std::os::raw::c_int, pub program_name: *mut wchar_t, pub pythonpath_env: *mut wchar_t, pub home: *mut wchar_t, pub platlibdir: *mut wchar_t, pub module_search_paths_set: ::std::os::raw::c_int, pub module_search_paths: PyWideStringList, pub stdlib_dir: *mut wchar_t, pub executable: *mut wchar_t, pub base_executable: *mut wchar_t, pub prefix: *mut wchar_t, pub base_prefix: *mut wchar_t, pub exec_prefix: *mut wchar_t, pub base_exec_prefix: *mut wchar_t, pub skip_source_first_line: ::std::os::raw::c_int, pub run_command: *mut wchar_t, pub run_module: *mut wchar_t, pub run_filename: *mut wchar_t, pub _install_importlib: ::std::os::raw::c_int, pub _init_main: ::std::os::raw::c_int, pub _isolated_interpreter: ::std::os::raw::c_int, pub _is_python_build: ::std::os::raw::c_int, } impl Default for PyConfig { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type Py_tracefunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyFrameObject, arg3: ::std::os::raw::c_int, arg4: *mut PyObject, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyTraceInfo { pub code: *mut PyCodeObject, pub bounds: PyCodeAddressRange, } impl Default for PyTraceInfo { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _PyCFrame { pub use_tracing: u8, pub current_frame: *mut _PyInterpreterFrame, pub previous: *mut _PyCFrame, } impl Default for _PyCFrame { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _err_stackitem { pub exc_value: *mut PyObject, pub previous_item: *mut _err_stackitem, } impl Default for _err_stackitem { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type _PyErr_StackItem = _err_stackitem; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _stack_chunk { pub previous: *mut _stack_chunk, pub size: usize, pub top: usize, pub data: [*mut PyObject; 1usize], } impl Default for _stack_chunk { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type _PyStackChunk = _stack_chunk; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _ts { pub prev: *mut PyThreadState, pub next: *mut PyThreadState, pub interp: *mut PyInterpreterState, pub _initialized: ::std::os::raw::c_int, pub _static: ::std::os::raw::c_int, pub recursion_remaining: ::std::os::raw::c_int, pub recursion_limit: ::std::os::raw::c_int, pub recursion_headroom: ::std::os::raw::c_int, pub tracing: ::std::os::raw::c_int, pub tracing_what: ::std::os::raw::c_int, pub cframe: *mut _PyCFrame, pub c_profilefunc: Py_tracefunc, pub c_tracefunc: Py_tracefunc, pub c_profileobj: *mut PyObject, pub c_traceobj: *mut PyObject, pub curexc_type: *mut PyObject, pub curexc_value: *mut PyObject, pub curexc_traceback: *mut PyObject, pub exc_info: *mut _PyErr_StackItem, pub dict: *mut PyObject, pub gilstate_counter: ::std::os::raw::c_int, pub async_exc: *mut PyObject, pub thread_id: ::std::os::raw::c_ulong, pub native_thread_id: ::std::os::raw::c_ulong, pub trash_delete_nesting: ::std::os::raw::c_int, pub trash_delete_later: *mut PyObject, pub on_delete: ::std::option::Option, pub on_delete_data: *mut ::std::os::raw::c_void, pub coroutine_origin_tracking_depth: ::std::os::raw::c_int, pub async_gen_firstiter: *mut PyObject, pub async_gen_finalizer: *mut PyObject, pub context: *mut PyObject, pub context_ver: u64, pub id: u64, pub trace_info: PyTraceInfo, pub datastack_chunk: *mut _PyStackChunk, pub datastack_top: *mut *mut PyObject, pub datastack_limit: *mut *mut PyObject, pub exc_state: _PyErr_StackItem, pub root_cframe: _PyCFrame, } impl Default for _ts { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type _PyFrameEvalFunction = ::std::option::Option< unsafe extern "C" fn( tstate: *mut PyThreadState, arg1: *mut _PyInterpreterFrame, arg2: ::std::os::raw::c_int, ) -> *mut PyObject, >; pub type getter = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_void) -> *mut PyObject, >; pub type setter = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyGetSetDef { pub name: *const ::std::os::raw::c_char, pub get: getter, pub set: setter, pub doc: *const ::std::os::raw::c_char, pub closure: *mut ::std::os::raw::c_void, } impl Default for PyGetSetDef { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyBaseExceptionObject { pub ob_base: PyObject, pub dict: *mut PyObject, pub args: *mut PyObject, pub notes: *mut PyObject, pub traceback: *mut PyObject, pub context: *mut PyObject, pub cause: *mut PyObject, pub suppress_context: ::std::os::raw::c_char, } impl Default for PyBaseExceptionObject { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type PyThread_type_lock = *mut ::std::os::raw::c_void; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_atomic_int { pub _value: ::std::os::raw::c_int, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct ast_state { pub initialized: ::std::os::raw::c_int, pub recursion_depth: ::std::os::raw::c_int, pub recursion_limit: ::std::os::raw::c_int, pub AST_type: *mut PyObject, pub Add_singleton: *mut PyObject, pub Add_type: *mut PyObject, pub And_singleton: *mut PyObject, pub And_type: *mut PyObject, pub AnnAssign_type: *mut PyObject, pub Assert_type: *mut PyObject, pub Assign_type: *mut PyObject, pub AsyncFor_type: *mut PyObject, pub AsyncFunctionDef_type: *mut PyObject, pub AsyncWith_type: *mut PyObject, pub Attribute_type: *mut PyObject, pub AugAssign_type: *mut PyObject, pub Await_type: *mut PyObject, pub BinOp_type: *mut PyObject, pub BitAnd_singleton: *mut PyObject, pub BitAnd_type: *mut PyObject, pub BitOr_singleton: *mut PyObject, pub BitOr_type: *mut PyObject, pub BitXor_singleton: *mut PyObject, pub BitXor_type: *mut PyObject, pub BoolOp_type: *mut PyObject, pub Break_type: *mut PyObject, pub Call_type: *mut PyObject, pub ClassDef_type: *mut PyObject, pub Compare_type: *mut PyObject, pub Constant_type: *mut PyObject, pub Continue_type: *mut PyObject, pub Del_singleton: *mut PyObject, pub Del_type: *mut PyObject, pub Delete_type: *mut PyObject, pub DictComp_type: *mut PyObject, pub Dict_type: *mut PyObject, pub Div_singleton: *mut PyObject, pub Div_type: *mut PyObject, pub Eq_singleton: *mut PyObject, pub Eq_type: *mut PyObject, pub ExceptHandler_type: *mut PyObject, pub Expr_type: *mut PyObject, pub Expression_type: *mut PyObject, pub FloorDiv_singleton: *mut PyObject, pub FloorDiv_type: *mut PyObject, pub For_type: *mut PyObject, pub FormattedValue_type: *mut PyObject, pub FunctionDef_type: *mut PyObject, pub FunctionType_type: *mut PyObject, pub GeneratorExp_type: *mut PyObject, pub Global_type: *mut PyObject, pub GtE_singleton: *mut PyObject, pub GtE_type: *mut PyObject, pub Gt_singleton: *mut PyObject, pub Gt_type: *mut PyObject, pub IfExp_type: *mut PyObject, pub If_type: *mut PyObject, pub ImportFrom_type: *mut PyObject, pub Import_type: *mut PyObject, pub In_singleton: *mut PyObject, pub In_type: *mut PyObject, pub Interactive_type: *mut PyObject, pub Invert_singleton: *mut PyObject, pub Invert_type: *mut PyObject, pub IsNot_singleton: *mut PyObject, pub IsNot_type: *mut PyObject, pub Is_singleton: *mut PyObject, pub Is_type: *mut PyObject, pub JoinedStr_type: *mut PyObject, pub LShift_singleton: *mut PyObject, pub LShift_type: *mut PyObject, pub Lambda_type: *mut PyObject, pub ListComp_type: *mut PyObject, pub List_type: *mut PyObject, pub Load_singleton: *mut PyObject, pub Load_type: *mut PyObject, pub LtE_singleton: *mut PyObject, pub LtE_type: *mut PyObject, pub Lt_singleton: *mut PyObject, pub Lt_type: *mut PyObject, pub MatMult_singleton: *mut PyObject, pub MatMult_type: *mut PyObject, pub MatchAs_type: *mut PyObject, pub MatchClass_type: *mut PyObject, pub MatchMapping_type: *mut PyObject, pub MatchOr_type: *mut PyObject, pub MatchSequence_type: *mut PyObject, pub MatchSingleton_type: *mut PyObject, pub MatchStar_type: *mut PyObject, pub MatchValue_type: *mut PyObject, pub Match_type: *mut PyObject, pub Mod_singleton: *mut PyObject, pub Mod_type: *mut PyObject, pub Module_type: *mut PyObject, pub Mult_singleton: *mut PyObject, pub Mult_type: *mut PyObject, pub Name_type: *mut PyObject, pub NamedExpr_type: *mut PyObject, pub Nonlocal_type: *mut PyObject, pub NotEq_singleton: *mut PyObject, pub NotEq_type: *mut PyObject, pub NotIn_singleton: *mut PyObject, pub NotIn_type: *mut PyObject, pub Not_singleton: *mut PyObject, pub Not_type: *mut PyObject, pub Or_singleton: *mut PyObject, pub Or_type: *mut PyObject, pub Pass_type: *mut PyObject, pub Pow_singleton: *mut PyObject, pub Pow_type: *mut PyObject, pub RShift_singleton: *mut PyObject, pub RShift_type: *mut PyObject, pub Raise_type: *mut PyObject, pub Return_type: *mut PyObject, pub SetComp_type: *mut PyObject, pub Set_type: *mut PyObject, pub Slice_type: *mut PyObject, pub Starred_type: *mut PyObject, pub Store_singleton: *mut PyObject, pub Store_type: *mut PyObject, pub Sub_singleton: *mut PyObject, pub Sub_type: *mut PyObject, pub Subscript_type: *mut PyObject, pub TryStar_type: *mut PyObject, pub Try_type: *mut PyObject, pub Tuple_type: *mut PyObject, pub TypeIgnore_type: *mut PyObject, pub UAdd_singleton: *mut PyObject, pub UAdd_type: *mut PyObject, pub USub_singleton: *mut PyObject, pub USub_type: *mut PyObject, pub UnaryOp_type: *mut PyObject, pub While_type: *mut PyObject, pub With_type: *mut PyObject, pub YieldFrom_type: *mut PyObject, pub Yield_type: *mut PyObject, pub __dict__: *mut PyObject, pub __doc__: *mut PyObject, pub __match_args__: *mut PyObject, pub __module__: *mut PyObject, pub _attributes: *mut PyObject, pub _fields: *mut PyObject, pub alias_type: *mut PyObject, pub annotation: *mut PyObject, pub arg: *mut PyObject, pub arg_type: *mut PyObject, pub args: *mut PyObject, pub argtypes: *mut PyObject, pub arguments_type: *mut PyObject, pub asname: *mut PyObject, pub ast: *mut PyObject, pub attr: *mut PyObject, pub bases: *mut PyObject, pub body: *mut PyObject, pub boolop_type: *mut PyObject, pub cases: *mut PyObject, pub cause: *mut PyObject, pub cls: *mut PyObject, pub cmpop_type: *mut PyObject, pub col_offset: *mut PyObject, pub comparators: *mut PyObject, pub comprehension_type: *mut PyObject, pub context_expr: *mut PyObject, pub conversion: *mut PyObject, pub ctx: *mut PyObject, pub decorator_list: *mut PyObject, pub defaults: *mut PyObject, pub elt: *mut PyObject, pub elts: *mut PyObject, pub end_col_offset: *mut PyObject, pub end_lineno: *mut PyObject, pub exc: *mut PyObject, pub excepthandler_type: *mut PyObject, pub expr_context_type: *mut PyObject, pub expr_type: *mut PyObject, pub finalbody: *mut PyObject, pub format_spec: *mut PyObject, pub func: *mut PyObject, pub generators: *mut PyObject, pub guard: *mut PyObject, pub handlers: *mut PyObject, pub id: *mut PyObject, pub ifs: *mut PyObject, pub is_async: *mut PyObject, pub items: *mut PyObject, pub iter: *mut PyObject, pub key: *mut PyObject, pub keys: *mut PyObject, pub keyword_type: *mut PyObject, pub keywords: *mut PyObject, pub kind: *mut PyObject, pub kw_defaults: *mut PyObject, pub kwarg: *mut PyObject, pub kwd_attrs: *mut PyObject, pub kwd_patterns: *mut PyObject, pub kwonlyargs: *mut PyObject, pub left: *mut PyObject, pub level: *mut PyObject, pub lineno: *mut PyObject, pub lower: *mut PyObject, pub match_case_type: *mut PyObject, pub mod_type: *mut PyObject, pub module: *mut PyObject, pub msg: *mut PyObject, pub name: *mut PyObject, pub names: *mut PyObject, pub op: *mut PyObject, pub operand: *mut PyObject, pub operator_type: *mut PyObject, pub ops: *mut PyObject, pub optional_vars: *mut PyObject, pub orelse: *mut PyObject, pub pattern: *mut PyObject, pub pattern_type: *mut PyObject, pub patterns: *mut PyObject, pub posonlyargs: *mut PyObject, pub rest: *mut PyObject, pub returns: *mut PyObject, pub right: *mut PyObject, pub simple: *mut PyObject, pub slice: *mut PyObject, pub step: *mut PyObject, pub stmt_type: *mut PyObject, pub subject: *mut PyObject, pub tag: *mut PyObject, pub target: *mut PyObject, pub targets: *mut PyObject, pub test: *mut PyObject, pub type_: *mut PyObject, pub type_comment: *mut PyObject, pub type_ignore_type: *mut PyObject, pub type_ignores: *mut PyObject, pub unaryop_type: *mut PyObject, pub upper: *mut PyObject, pub value: *mut PyObject, pub values: *mut PyObject, pub vararg: *mut PyObject, pub withitem_type: *mut PyObject, } impl Default for ast_state { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct callable_cache { pub isinstance: *mut PyObject, pub len: *mut PyObject, pub list_append: *mut PyObject, } impl Default for callable_cache { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_context_state {} #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_dict_state {} #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyDictUnicodeEntry { pub me_key: *mut PyObject, pub me_value: *mut PyObject, } impl Default for PyDictUnicodeEntry { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _dictkeysobject { pub dk_refcnt: Py_ssize_t, pub dk_log2_size: u8, pub dk_log2_index_bytes: u8, pub dk_kind: u8, pub dk_version: u32, pub dk_usable: Py_ssize_t, pub dk_nentries: Py_ssize_t, pub dk_indices: [std::os::raw::c_char; 0], } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _dictvalues { pub values: [*mut PyObject; 1usize], } impl Default for _dictvalues { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_exc_state { pub errnomap: *mut PyObject, pub memerrors_freelist: *mut PyBaseExceptionObject, pub memerrors_numfree: ::std::os::raw::c_int, pub PyExc_ExceptionGroup: *mut PyObject, } impl Default for _Py_exc_state { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_float_state {} #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_async_gen_state {} #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct PyGC_Head { pub _gc_next: usize, pub _gc_prev: usize, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct gc_generation { pub head: PyGC_Head, pub threshold: ::std::os::raw::c_int, pub count: ::std::os::raw::c_int, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct gc_generation_stats { pub collections: Py_ssize_t, pub collected: Py_ssize_t, pub uncollectable: Py_ssize_t, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _gc_runtime_state { pub trash_delete_later: *mut PyObject, pub trash_delete_nesting: ::std::os::raw::c_int, pub enabled: ::std::os::raw::c_int, pub debug: ::std::os::raw::c_int, pub generations: [gc_generation; 3usize], pub generation0: *mut PyGC_Head, pub permanent_generation: gc_generation, pub generation_stats: [gc_generation_stats; 3usize], pub collecting: ::std::os::raw::c_int, pub garbage: *mut PyObject, pub callbacks: *mut PyObject, pub long_lived_total: Py_ssize_t, pub long_lived_pending: Py_ssize_t, } impl Default for _gc_runtime_state { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_list_state {} #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_tuple_state { pub _unused: ::std::os::raw::c_char, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct type_cache_entry { pub version: ::std::os::raw::c_uint, pub name: *mut PyObject, pub value: *mut PyObject, } impl Default for type_cache_entry { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct type_cache { pub hashtable: [type_cache_entry; 4096usize], } impl Default for type_cache { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub const _Py_error_handler__Py_ERROR_UNKNOWN: _Py_error_handler = 0; pub const _Py_error_handler__Py_ERROR_STRICT: _Py_error_handler = 1; pub const _Py_error_handler__Py_ERROR_SURROGATEESCAPE: _Py_error_handler = 2; pub const _Py_error_handler__Py_ERROR_REPLACE: _Py_error_handler = 3; pub const _Py_error_handler__Py_ERROR_IGNORE: _Py_error_handler = 4; pub const _Py_error_handler__Py_ERROR_BACKSLASHREPLACE: _Py_error_handler = 5; pub const _Py_error_handler__Py_ERROR_SURROGATEPASS: _Py_error_handler = 6; pub const _Py_error_handler__Py_ERROR_XMLCHARREFREPLACE: _Py_error_handler = 7; pub const _Py_error_handler__Py_ERROR_OTHER: _Py_error_handler = 8; pub type _Py_error_handler = ::std::os::raw::c_uint; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_unicode_fs_codec { pub encoding: *mut ::std::os::raw::c_char, pub utf8: ::std::os::raw::c_int, pub errors: *mut ::std::os::raw::c_char, pub error_handler: _Py_error_handler, } impl Default for _Py_unicode_fs_codec { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_unicode_ids { pub size: Py_ssize_t, pub array: *mut *mut PyObject, } impl Default for _Py_unicode_ids { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_unicode_state { pub fs_codec: _Py_unicode_fs_codec, pub ids: _Py_unicode_ids, } impl Default for _Py_unicode_state { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _warnings_runtime_state { pub filters: *mut PyObject, pub once_registry: *mut PyObject, pub default_action: *mut PyObject, pub filters_version: ::std::os::raw::c_long, } impl Default for _warnings_runtime_state { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _pending_calls { pub lock: PyThread_type_lock, pub calls_to_do: _Py_atomic_int, pub async_exc: ::std::os::raw::c_int, pub calls: [_pending_calls__bindgen_ty_1; 32usize], pub first: ::std::os::raw::c_int, pub last: ::std::os::raw::c_int, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _pending_calls__bindgen_ty_1 { pub func: ::std::option::Option< unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, >, pub arg: *mut ::std::os::raw::c_void, } impl Default for _pending_calls__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } impl Default for _pending_calls { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _ceval_state { pub recursion_limit: ::std::os::raw::c_int, pub eval_breaker: _Py_atomic_int, pub gil_drop_request: _Py_atomic_int, pub pending: _pending_calls, } impl Default for _ceval_state { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct atexit_callback { pub func: *mut PyObject, pub args: *mut PyObject, pub kwargs: *mut PyObject, } impl Default for atexit_callback { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct atexit_state { pub callbacks: *mut *mut atexit_callback, pub ncallbacks: ::std::os::raw::c_int, pub callback_len: ::std::os::raw::c_int, } impl Default for atexit_state { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _is { pub next: *mut PyInterpreterState, pub threads: _is_pythreads, pub runtime: *mut pyruntimestate, pub id: i64, pub id_refcount: i64, pub requires_idref: ::std::os::raw::c_int, pub id_mutex: PyThread_type_lock, pub _initialized: ::std::os::raw::c_int, pub finalizing: ::std::os::raw::c_int, pub _static: bool, pub ceval: _ceval_state, pub gc: _gc_runtime_state, pub modules: *mut PyObject, pub modules_by_index: *mut PyObject, pub sysdict: *mut PyObject, pub builtins: *mut PyObject, pub importlib: *mut PyObject, pub override_frozen_modules: ::std::os::raw::c_int, pub codec_search_path: *mut PyObject, pub codec_search_cache: *mut PyObject, pub codec_error_registry: *mut PyObject, pub codecs_initialized: ::std::os::raw::c_int, pub config: PyConfig, pub dlopenflags: ::std::os::raw::c_int, pub dict: *mut PyObject, pub builtins_copy: *mut PyObject, pub import_func: *mut PyObject, pub eval_frame: _PyFrameEvalFunction, pub co_extra_user_count: Py_ssize_t, pub co_extra_freefuncs: [freefunc; 255usize], pub before_forkers: *mut PyObject, pub after_forkers_parent: *mut PyObject, pub after_forkers_child: *mut PyObject, pub warnings: _warnings_runtime_state, pub atexit: atexit_state, pub audit_hooks: *mut PyObject, pub unicode: _Py_unicode_state, pub float_state: _Py_float_state, pub slice_cache: *mut PySliceObject, pub tuple: _Py_tuple_state, pub list: _Py_list_state, pub dict_state: _Py_dict_state, pub async_gen: _Py_async_gen_state, pub context: _Py_context_state, pub exc_state: _Py_exc_state, pub ast: ast_state, pub type_cache: type_cache, pub callable_cache: callable_cache, pub int_max_str_digits: ::std::os::raw::c_int, pub _initial_thread: PyThreadState, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _is_pythreads { pub next_unique_id: u64, pub head: *mut PyThreadState, pub count: ::std::os::raw::c_long, pub stacksize: usize, } impl Default for _is_pythreads { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } impl Default for _is { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _frame { pub ob_base: PyObject, pub f_back: *mut PyFrameObject, pub f_frame: *mut _PyInterpreterFrame, pub f_trace: *mut PyObject, pub f_lineno: ::std::os::raw::c_int, pub f_trace_lines: ::std::os::raw::c_char, pub f_trace_opcodes: ::std::os::raw::c_char, pub f_fast_as_locals: ::std::os::raw::c_char, pub _f_frame_data: [*mut PyObject; 1usize], } impl Default for _frame { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _PyInterpreterFrame { pub f_func: *mut PyFunctionObject, pub f_globals: *mut PyObject, pub f_builtins: *mut PyObject, pub f_locals: *mut PyObject, pub f_code: *mut PyCodeObject, pub frame_obj: *mut PyFrameObject, pub previous: *mut _PyInterpreterFrame, pub prev_instr: *mut _Py_CODEUNIT, pub stacktop: ::std::os::raw::c_int, pub is_entry: bool, pub owner: ::std::os::raw::c_char, pub localsplus: [*mut PyObject; 1usize], } impl Default for _PyInterpreterFrame { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct pyruntimestate { pub _address: u8, } ================================================ FILE: src/python_bindings/v3_12_0.rs ================================================ // Generated bindings for python v3.12.0 #![allow(dead_code)] #![allow(non_upper_case_globals)] #![allow(non_camel_case_types)] #![allow(non_snake_case)] #![allow(clippy::useless_transmute)] #![allow(clippy::default_trait_access)] #![allow(clippy::cast_lossless)] #![allow(clippy::trivially_copy_pass_by_ref)] #![allow(clippy::upper_case_acronyms)] #![allow(clippy::too_many_arguments)] /* automatically generated by rust-bindgen 0.72.0 */ #[repr(C)] #[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] pub struct __BindgenBitfieldUnit { storage: Storage, } impl __BindgenBitfieldUnit { #[inline] pub const fn new(storage: Storage) -> Self { Self { storage } } } impl __BindgenBitfieldUnit where Storage: AsRef<[u8]> + AsMut<[u8]>, { #[inline] fn extract_bit(byte: u8, index: usize) -> bool { let bit_index = if cfg!(target_endian = "big") { 7 - (index % 8) } else { index % 8 }; let mask = 1 << bit_index; byte & mask == mask } #[inline] pub fn get_bit(&self, index: usize) -> bool { debug_assert!(index / 8 < self.storage.as_ref().len()); let byte_index = index / 8; let byte = self.storage.as_ref()[byte_index]; Self::extract_bit(byte, index) } #[inline] pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { debug_assert!(index / 8 < core::mem::size_of::()); let byte_index = index / 8; let byte = unsafe { *(core::ptr::addr_of!((*this).storage) as *const u8).add(byte_index) }; Self::extract_bit(byte, index) } #[inline] fn change_bit(byte: u8, index: usize, val: bool) -> u8 { let bit_index = if cfg!(target_endian = "big") { 7 - (index % 8) } else { index % 8 }; let mask = 1 << bit_index; if val { byte | mask } else { byte & !mask } } #[inline] pub fn set_bit(&mut self, index: usize, val: bool) { debug_assert!(index / 8 < self.storage.as_ref().len()); let byte_index = index / 8; let byte = &mut self.storage.as_mut()[byte_index]; *byte = Self::change_bit(*byte, index, val); } #[inline] pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { debug_assert!(index / 8 < core::mem::size_of::()); let byte_index = index / 8; let byte = unsafe { (core::ptr::addr_of_mut!((*this).storage) as *mut u8).add(byte_index) }; unsafe { *byte = Self::change_bit(*byte, index, val) }; } #[inline] pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); let mut val = 0; for i in 0..(bit_width as usize) { if self.get_bit(i + bit_offset) { let index = if cfg!(target_endian = "big") { bit_width as usize - 1 - i } else { i }; val |= 1 << index; } } val } #[inline] pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::()); let mut val = 0; for i in 0..(bit_width as usize) { if unsafe { Self::raw_get_bit(this, i + bit_offset) } { let index = if cfg!(target_endian = "big") { bit_width as usize - 1 - i } else { i }; val |= 1 << index; } } val } #[inline] pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); for i in 0..(bit_width as usize) { let mask = 1 << i; let val_bit_is_set = val & mask == mask; let index = if cfg!(target_endian = "big") { bit_width as usize - 1 - i } else { i }; self.set_bit(index + bit_offset, val_bit_is_set); } } #[inline] pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::()); for i in 0..(bit_width as usize) { let mask = 1 << i; let val_bit_is_set = val & mask == mask; let index = if cfg!(target_endian = "big") { bit_width as usize - 1 - i } else { i }; unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) }; } } } #[repr(C)] #[derive(Default)] pub struct __IncompleteArrayField(::std::marker::PhantomData, [T; 0]); impl __IncompleteArrayField { #[inline] pub const fn new() -> Self { __IncompleteArrayField(::std::marker::PhantomData, []) } #[inline] pub fn as_ptr(&self) -> *const T { self as *const _ as *const T } #[inline] pub fn as_mut_ptr(&mut self) -> *mut T { self as *mut _ as *mut T } #[inline] pub unsafe fn as_slice(&self, len: usize) -> &[T] { ::std::slice::from_raw_parts(self.as_ptr(), len) } #[inline] pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] { ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len) } } impl ::std::fmt::Debug for __IncompleteArrayField { fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { fmt.write_str("__IncompleteArrayField") } } pub type wchar_t = ::std::os::raw::c_int; pub type __uint32_t = ::std::os::raw::c_uint; pub type __dev_t = ::std::os::raw::c_ulong; pub type __uid_t = ::std::os::raw::c_uint; pub type __ino64_t = ::std::os::raw::c_ulong; pub type __pid_t = ::std::os::raw::c_int; pub type __clock_t = ::std::os::raw::c_long; pub type __sig_atomic_t = ::std::os::raw::c_int; pub type ino_t = __ino64_t; pub type dev_t = __dev_t; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct __sigset_t { pub __val: [::std::os::raw::c_ulong; 16usize], } #[repr(C)] #[derive(Copy, Clone)] pub union __atomic_wide_counter { pub __value64: ::std::os::raw::c_ulonglong, pub __value32: __atomic_wide_counter__bindgen_ty_1, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct __atomic_wide_counter__bindgen_ty_1 { pub __low: ::std::os::raw::c_uint, pub __high: ::std::os::raw::c_uint, } impl Default for __atomic_wide_counter { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct __pthread_internal_list { pub __prev: *mut __pthread_internal_list, pub __next: *mut __pthread_internal_list, } impl Default for __pthread_internal_list { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type __pthread_list_t = __pthread_internal_list; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct __pthread_mutex_s { pub __lock: ::std::os::raw::c_int, pub __count: ::std::os::raw::c_uint, pub __owner: ::std::os::raw::c_int, pub __nusers: ::std::os::raw::c_uint, pub __kind: ::std::os::raw::c_int, pub __spins: ::std::os::raw::c_short, pub __elision: ::std::os::raw::c_short, pub __list: __pthread_list_t, } impl Default for __pthread_mutex_s { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct __pthread_cond_s { pub __wseq: __atomic_wide_counter, pub __g1_start: __atomic_wide_counter, pub __g_refs: [::std::os::raw::c_uint; 2usize], pub __g_size: [::std::os::raw::c_uint; 2usize], pub __g1_orig_size: ::std::os::raw::c_uint, pub __wrefs: ::std::os::raw::c_uint, pub __g_signals: [::std::os::raw::c_uint; 2usize], } impl Default for __pthread_cond_s { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub union pthread_condattr_t { pub __size: [::std::os::raw::c_char; 4usize], pub __align: ::std::os::raw::c_int, } impl Default for pthread_condattr_t { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type pthread_key_t = ::std::os::raw::c_uint; #[repr(C)] #[derive(Copy, Clone)] pub union pthread_mutex_t { pub __data: __pthread_mutex_s, pub __size: [::std::os::raw::c_char; 40usize], pub __align: ::std::os::raw::c_long, } impl Default for pthread_mutex_t { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub union pthread_cond_t { pub __data: __pthread_cond_s, pub __size: [::std::os::raw::c_char; 48usize], pub __align: ::std::os::raw::c_longlong, } impl Default for pthread_cond_t { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type Py_ssize_t = isize; pub type Py_hash_t = Py_ssize_t; pub type Py_uhash_t = usize; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyMemAllocatorEx { pub ctx: *mut ::std::os::raw::c_void, pub malloc: ::std::option::Option< unsafe extern "C" fn( ctx: *mut ::std::os::raw::c_void, size: usize, ) -> *mut ::std::os::raw::c_void, >, pub calloc: ::std::option::Option< unsafe extern "C" fn( ctx: *mut ::std::os::raw::c_void, nelem: usize, elsize: usize, ) -> *mut ::std::os::raw::c_void, >, pub realloc: ::std::option::Option< unsafe extern "C" fn( ctx: *mut ::std::os::raw::c_void, ptr: *mut ::std::os::raw::c_void, new_size: usize, ) -> *mut ::std::os::raw::c_void, >, pub free: ::std::option::Option< unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, ptr: *mut ::std::os::raw::c_void), >, } impl Default for PyMemAllocatorEx { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type PyObject = _object; pub type PyLongObject = _longobject; pub type PyTypeObject = _typeobject; pub type PyFrameObject = _frame; pub type PyThreadState = _ts; pub type PyInterpreterState = _is; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct Py_buffer { pub buf: *mut ::std::os::raw::c_void, pub obj: *mut PyObject, pub len: Py_ssize_t, pub itemsize: Py_ssize_t, pub readonly: ::std::os::raw::c_int, pub ndim: ::std::os::raw::c_int, pub format: *mut ::std::os::raw::c_char, pub shape: *mut Py_ssize_t, pub strides: *mut Py_ssize_t, pub suboffsets: *mut Py_ssize_t, pub internal: *mut ::std::os::raw::c_void, } impl Default for Py_buffer { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type getbufferproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut Py_buffer, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >; pub type releasebufferproc = ::std::option::Option; #[repr(C)] #[derive(Copy, Clone)] pub struct _object { pub __bindgen_anon_1: _object__bindgen_ty_1, pub ob_type: *mut PyTypeObject, } #[repr(C)] #[derive(Copy, Clone)] pub union _object__bindgen_ty_1 { pub ob_refcnt: Py_ssize_t, // line manually added, see https://github.com/benfred/py-spy/issues/753 #[cfg(target_pointer_width = "64")] pub ob_refcnt_split: [u32; 2usize], // line manually added, see https://github.com/benfred/py-spy/issues/753 #[cfg(target_pointer_width = "64")] _bindgen_union_align: u64, } impl Default for _object__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } impl Default for _object { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct PyVarObject { pub ob_base: PyObject, pub ob_size: Py_ssize_t, } impl Default for PyVarObject { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type unaryfunc = ::std::option::Option *mut PyObject>; pub type binaryfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject, >; pub type ternaryfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> *mut PyObject, >; pub type inquiry = ::std::option::Option ::std::os::raw::c_int>; pub type lenfunc = ::std::option::Option Py_ssize_t>; pub type ssizeargfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: Py_ssize_t) -> *mut PyObject, >; pub type ssizeobjargproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: Py_ssize_t, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type objobjargproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type objobjproc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> ::std::os::raw::c_int, >; pub type visitproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; pub type traverseproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: visitproc, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; pub type freefunc = ::std::option::Option; pub type destructor = ::std::option::Option; pub type getattrfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_char) -> *mut PyObject, >; pub type getattrofunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject, >; pub type setattrfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_char, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type setattrofunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type reprfunc = ::std::option::Option *mut PyObject>; pub type hashfunc = ::std::option::Option Py_hash_t>; pub type richcmpfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: ::std::os::raw::c_int, ) -> *mut PyObject, >; pub type getiterfunc = ::std::option::Option *mut PyObject>; pub type iternextfunc = ::std::option::Option *mut PyObject>; pub type descrgetfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> *mut PyObject, >; pub type descrsetfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type initproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type newfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyTypeObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> *mut PyObject, >; pub type allocfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyTypeObject, arg2: Py_ssize_t) -> *mut PyObject, >; pub type vectorcallfunc = ::std::option::Option< unsafe extern "C" fn( callable: *mut PyObject, args: *const *mut PyObject, nargsf: usize, kwnames: *mut PyObject, ) -> *mut PyObject, >; pub const PySendResult_PYGEN_RETURN: PySendResult = 0; pub const PySendResult_PYGEN_ERROR: PySendResult = -1; pub const PySendResult_PYGEN_NEXT: PySendResult = 1; pub type PySendResult = ::std::os::raw::c_int; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyNumberMethods { pub nb_add: binaryfunc, pub nb_subtract: binaryfunc, pub nb_multiply: binaryfunc, pub nb_remainder: binaryfunc, pub nb_divmod: binaryfunc, pub nb_power: ternaryfunc, pub nb_negative: unaryfunc, pub nb_positive: unaryfunc, pub nb_absolute: unaryfunc, pub nb_bool: inquiry, pub nb_invert: unaryfunc, pub nb_lshift: binaryfunc, pub nb_rshift: binaryfunc, pub nb_and: binaryfunc, pub nb_xor: binaryfunc, pub nb_or: binaryfunc, pub nb_int: unaryfunc, pub nb_reserved: *mut ::std::os::raw::c_void, pub nb_float: unaryfunc, pub nb_inplace_add: binaryfunc, pub nb_inplace_subtract: binaryfunc, pub nb_inplace_multiply: binaryfunc, pub nb_inplace_remainder: binaryfunc, pub nb_inplace_power: ternaryfunc, pub nb_inplace_lshift: binaryfunc, pub nb_inplace_rshift: binaryfunc, pub nb_inplace_and: binaryfunc, pub nb_inplace_xor: binaryfunc, pub nb_inplace_or: binaryfunc, pub nb_floor_divide: binaryfunc, pub nb_true_divide: binaryfunc, pub nb_inplace_floor_divide: binaryfunc, pub nb_inplace_true_divide: binaryfunc, pub nb_index: unaryfunc, pub nb_matrix_multiply: binaryfunc, pub nb_inplace_matrix_multiply: binaryfunc, } impl Default for PyNumberMethods { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PySequenceMethods { pub sq_length: lenfunc, pub sq_concat: binaryfunc, pub sq_repeat: ssizeargfunc, pub sq_item: ssizeargfunc, pub was_sq_slice: *mut ::std::os::raw::c_void, pub sq_ass_item: ssizeobjargproc, pub was_sq_ass_slice: *mut ::std::os::raw::c_void, pub sq_contains: objobjproc, pub sq_inplace_concat: binaryfunc, pub sq_inplace_repeat: ssizeargfunc, } impl Default for PySequenceMethods { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct PyMappingMethods { pub mp_length: lenfunc, pub mp_subscript: binaryfunc, pub mp_ass_subscript: objobjargproc, } pub type sendfunc = ::std::option::Option< unsafe extern "C" fn( iter: *mut PyObject, value: *mut PyObject, result: *mut *mut PyObject, ) -> PySendResult, >; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct PyAsyncMethods { pub am_await: unaryfunc, pub am_aiter: unaryfunc, pub am_anext: unaryfunc, pub am_send: sendfunc, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct PyBufferProcs { pub bf_getbuffer: getbufferproc, pub bf_releasebuffer: releasebufferproc, } #[repr(C)] #[derive(Copy, Clone)] pub struct _typeobject { pub ob_base: PyVarObject, pub tp_name: *const ::std::os::raw::c_char, pub tp_basicsize: Py_ssize_t, pub tp_itemsize: Py_ssize_t, pub tp_dealloc: destructor, pub tp_vectorcall_offset: Py_ssize_t, pub tp_getattr: getattrfunc, pub tp_setattr: setattrfunc, pub tp_as_async: *mut PyAsyncMethods, pub tp_repr: reprfunc, pub tp_as_number: *mut PyNumberMethods, pub tp_as_sequence: *mut PySequenceMethods, pub tp_as_mapping: *mut PyMappingMethods, pub tp_hash: hashfunc, pub tp_call: ternaryfunc, pub tp_str: reprfunc, pub tp_getattro: getattrofunc, pub tp_setattro: setattrofunc, pub tp_as_buffer: *mut PyBufferProcs, pub tp_flags: ::std::os::raw::c_ulong, pub tp_doc: *const ::std::os::raw::c_char, pub tp_traverse: traverseproc, pub tp_clear: inquiry, pub tp_richcompare: richcmpfunc, pub tp_weaklistoffset: Py_ssize_t, pub tp_iter: getiterfunc, pub tp_iternext: iternextfunc, pub tp_methods: *mut PyMethodDef, pub tp_members: *mut PyMemberDef, pub tp_getset: *mut PyGetSetDef, pub tp_base: *mut PyTypeObject, pub tp_dict: *mut PyObject, pub tp_descr_get: descrgetfunc, pub tp_descr_set: descrsetfunc, pub tp_dictoffset: Py_ssize_t, pub tp_init: initproc, pub tp_alloc: allocfunc, pub tp_new: newfunc, pub tp_free: freefunc, pub tp_is_gc: inquiry, pub tp_bases: *mut PyObject, pub tp_mro: *mut PyObject, pub tp_cache: *mut PyObject, pub tp_subclasses: *mut ::std::os::raw::c_void, pub tp_weaklist: *mut PyObject, pub tp_del: destructor, pub tp_version_tag: ::std::os::raw::c_uint, pub tp_finalize: destructor, pub tp_vectorcall: vectorcallfunc, pub tp_watched: ::std::os::raw::c_uchar, } impl Default for _typeobject { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _specialization_cache { pub getitem: *mut PyObject, pub getitem_version: u32, } impl Default for _specialization_cache { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _heaptypeobject { pub ht_type: PyTypeObject, pub as_async: PyAsyncMethods, pub as_number: PyNumberMethods, pub as_mapping: PyMappingMethods, pub as_sequence: PySequenceMethods, pub as_buffer: PyBufferProcs, pub ht_name: *mut PyObject, pub ht_slots: *mut PyObject, pub ht_qualname: *mut PyObject, pub ht_cached_keys: *mut _dictkeysobject, pub ht_module: *mut PyObject, pub _ht_tpname: *mut ::std::os::raw::c_char, pub _spec_cache: _specialization_cache, } impl Default for _heaptypeobject { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type PyHeapTypeObject = _heaptypeobject; pub type PyType_WatchCallback = ::std::option::Option ::std::os::raw::c_int>; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyObjectArenaAllocator { pub ctx: *mut ::std::os::raw::c_void, pub alloc: ::std::option::Option< unsafe extern "C" fn( ctx: *mut ::std::os::raw::c_void, size: usize, ) -> *mut ::std::os::raw::c_void, >, pub free: ::std::option::Option< unsafe extern "C" fn( ctx: *mut ::std::os::raw::c_void, ptr: *mut ::std::os::raw::c_void, size: usize, ), >, } impl Default for PyObjectArenaAllocator { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct PyBytesObject { pub ob_base: PyVarObject, pub ob_shash: Py_hash_t, pub ob_sval: [::std::os::raw::c_char; 1usize], } impl Default for PyBytesObject { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type Py_UCS4 = u32; pub type Py_UCS2 = u16; pub type Py_UCS1 = u8; #[repr(C)] #[derive(Copy, Clone)] pub struct PyASCIIObject { pub ob_base: PyObject, pub length: Py_ssize_t, pub hash: Py_hash_t, pub state: PyASCIIObject__bindgen_ty_1, } #[repr(C)] #[repr(align(4))] #[derive(Debug, Default, Copy, Clone)] pub struct PyASCIIObject__bindgen_ty_1 { pub _bitfield_align_1: [u8; 0], pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, } impl PyASCIIObject__bindgen_ty_1 { #[inline] pub fn interned(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) } } #[inline] pub fn set_interned(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(0usize, 2u8, val as u64) } } #[inline] pub unsafe fn interned_raw(this: *const Self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( ::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 2u8, ) as u32) } } #[inline] pub unsafe fn set_interned_raw(this: *mut Self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( ::std::ptr::addr_of_mut!((*this)._bitfield_1), 0usize, 2u8, val as u64, ) } } #[inline] pub fn kind(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 3u8) as u32) } } #[inline] pub fn set_kind(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(2usize, 3u8, val as u64) } } #[inline] pub unsafe fn kind_raw(this: *const Self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( ::std::ptr::addr_of!((*this)._bitfield_1), 2usize, 3u8, ) as u32) } } #[inline] pub unsafe fn set_kind_raw(this: *mut Self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( ::std::ptr::addr_of_mut!((*this)._bitfield_1), 2usize, 3u8, val as u64, ) } } #[inline] pub fn compact(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } } #[inline] pub fn set_compact(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(5usize, 1u8, val as u64) } } #[inline] pub unsafe fn compact_raw(this: *const Self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( ::std::ptr::addr_of!((*this)._bitfield_1), 5usize, 1u8, ) as u32) } } #[inline] pub unsafe fn set_compact_raw(this: *mut Self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( ::std::ptr::addr_of_mut!((*this)._bitfield_1), 5usize, 1u8, val as u64, ) } } #[inline] pub fn ascii(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } } #[inline] pub fn set_ascii(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(6usize, 1u8, val as u64) } } #[inline] pub unsafe fn ascii_raw(this: *const Self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( ::std::ptr::addr_of!((*this)._bitfield_1), 6usize, 1u8, ) as u32) } } #[inline] pub unsafe fn set_ascii_raw(this: *mut Self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( ::std::ptr::addr_of_mut!((*this)._bitfield_1), 6usize, 1u8, val as u64, ) } } #[inline] pub fn new_bitfield_1( interned: ::std::os::raw::c_uint, kind: ::std::os::raw::c_uint, compact: ::std::os::raw::c_uint, ascii: ::std::os::raw::c_uint, ) -> __BindgenBitfieldUnit<[u8; 4usize]> { let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); __bindgen_bitfield_unit.set(0usize, 2u8, { let interned: u32 = unsafe { ::std::mem::transmute(interned) }; interned as u64 }); __bindgen_bitfield_unit.set(2usize, 3u8, { let kind: u32 = unsafe { ::std::mem::transmute(kind) }; kind as u64 }); __bindgen_bitfield_unit.set(5usize, 1u8, { let compact: u32 = unsafe { ::std::mem::transmute(compact) }; compact as u64 }); __bindgen_bitfield_unit.set(6usize, 1u8, { let ascii: u32 = unsafe { ::std::mem::transmute(ascii) }; ascii as u64 }); __bindgen_bitfield_unit } } impl Default for PyASCIIObject { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct PyCompactUnicodeObject { pub _base: PyASCIIObject, pub utf8_length: Py_ssize_t, pub utf8: *mut ::std::os::raw::c_char, } impl Default for PyCompactUnicodeObject { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct PyUnicodeObject { pub _base: PyCompactUnicodeObject, pub data: PyUnicodeObject__bindgen_ty_1, } #[repr(C)] #[derive(Copy, Clone)] pub union PyUnicodeObject__bindgen_ty_1 { pub any: *mut ::std::os::raw::c_void, pub latin1: *mut Py_UCS1, pub ucs2: *mut Py_UCS2, pub ucs4: *mut Py_UCS4, } impl Default for PyUnicodeObject__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } impl Default for PyUnicodeObject { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type digit = u32; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _PyLongValue { pub lv_tag: usize, pub ob_digit: [digit; 1usize], } #[repr(C)] #[derive(Copy, Clone)] pub struct _longobject { pub ob_base: PyObject, pub long_value: _PyLongValue, } impl Default for _longobject { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct PyFloatObject { pub ob_base: PyObject, pub ob_fval: f64, } impl Default for PyFloatObject { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct PyTupleObject { pub ob_base: PyVarObject, pub ob_item: [*mut PyObject; 1usize], } impl Default for PyTupleObject { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct PyListObject { pub ob_base: PyVarObject, pub ob_item: *mut *mut PyObject, pub allocated: Py_ssize_t, } impl Default for PyListObject { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type PyDictKeysObject = _dictkeysobject; pub type PyDictValues = _dictvalues; #[repr(C)] #[derive(Copy, Clone)] pub struct PyDictObject { pub ob_base: PyObject, pub ma_used: Py_ssize_t, pub ma_version_tag: u64, pub ma_keys: *mut PyDictKeysObject, pub ma_values: *mut PyDictValues, } impl Default for PyDictObject { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub const PyDict_WatchEvent_PyDict_EVENT_ADDED: PyDict_WatchEvent = 0; pub const PyDict_WatchEvent_PyDict_EVENT_MODIFIED: PyDict_WatchEvent = 1; pub const PyDict_WatchEvent_PyDict_EVENT_DELETED: PyDict_WatchEvent = 2; pub const PyDict_WatchEvent_PyDict_EVENT_CLONED: PyDict_WatchEvent = 3; pub const PyDict_WatchEvent_PyDict_EVENT_CLEARED: PyDict_WatchEvent = 4; pub const PyDict_WatchEvent_PyDict_EVENT_DEALLOCATED: PyDict_WatchEvent = 5; pub type PyDict_WatchEvent = ::std::os::raw::c_uint; pub type PyDict_WatchCallback = ::std::option::Option< unsafe extern "C" fn( event: PyDict_WatchEvent, dict: *mut PyObject, key: *mut PyObject, new_value: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type PyCFunction = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyMethodDef { pub ml_name: *const ::std::os::raw::c_char, pub ml_meth: PyCFunction, pub ml_flags: ::std::os::raw::c_int, pub ml_doc: *const ::std::os::raw::c_char, } impl Default for PyMethodDef { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct PyFunctionObject { pub ob_base: PyObject, pub func_globals: *mut PyObject, pub func_builtins: *mut PyObject, pub func_name: *mut PyObject, pub func_qualname: *mut PyObject, pub func_code: *mut PyObject, pub func_defaults: *mut PyObject, pub func_kwdefaults: *mut PyObject, pub func_closure: *mut PyObject, pub func_doc: *mut PyObject, pub func_dict: *mut PyObject, pub func_weakreflist: *mut PyObject, pub func_module: *mut PyObject, pub func_annotations: *mut PyObject, pub func_typeparams: *mut PyObject, pub vectorcall: vectorcallfunc, pub func_version: u32, } impl Default for PyFunctionObject { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub const PyFunction_WatchEvent_PyFunction_EVENT_CREATE: PyFunction_WatchEvent = 0; pub const PyFunction_WatchEvent_PyFunction_EVENT_DESTROY: PyFunction_WatchEvent = 1; pub const PyFunction_WatchEvent_PyFunction_EVENT_MODIFY_CODE: PyFunction_WatchEvent = 2; pub const PyFunction_WatchEvent_PyFunction_EVENT_MODIFY_DEFAULTS: PyFunction_WatchEvent = 3; pub const PyFunction_WatchEvent_PyFunction_EVENT_MODIFY_KWDEFAULTS: PyFunction_WatchEvent = 4; pub type PyFunction_WatchEvent = ::std::os::raw::c_uint; pub type PyFunction_WatchCallback = ::std::option::Option< unsafe extern "C" fn( event: PyFunction_WatchEvent, func: *mut PyFunctionObject, new_value: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type Py_OpenCodeHookFunction = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_void) -> *mut PyObject, >; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_LocalMonitors { pub tools: [u8; 15usize], } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_GlobalMonitors { pub tools: [u8; 15usize], } #[repr(C)] #[derive(Copy, Clone)] pub union _Py_CODEUNIT { pub cache: u16, pub op: _Py_CODEUNIT__bindgen_ty_1, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_CODEUNIT__bindgen_ty_1 { pub code: u8, pub arg: u8, } impl Default for _Py_CODEUNIT { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _PyCoCached { pub _co_code: *mut PyObject, pub _co_varnames: *mut PyObject, pub _co_cellvars: *mut PyObject, pub _co_freevars: *mut PyObject, } impl Default for _PyCoCached { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _PyCoLineInstrumentationData { pub original_opcode: u8, pub line_delta: i8, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _PyCoMonitoringData { pub local_monitors: _Py_LocalMonitors, pub active_monitors: _Py_LocalMonitors, pub tools: *mut u8, pub lines: *mut _PyCoLineInstrumentationData, pub line_tools: *mut u8, pub per_instruction_opcodes: *mut u8, pub per_instruction_tools: *mut u8, } impl Default for _PyCoMonitoringData { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct PyCodeObject { pub ob_base: PyVarObject, pub co_consts: *mut PyObject, pub co_names: *mut PyObject, pub co_exceptiontable: *mut PyObject, pub co_flags: ::std::os::raw::c_int, pub co_argcount: ::std::os::raw::c_int, pub co_posonlyargcount: ::std::os::raw::c_int, pub co_kwonlyargcount: ::std::os::raw::c_int, pub co_stacksize: ::std::os::raw::c_int, pub co_firstlineno: ::std::os::raw::c_int, pub co_nlocalsplus: ::std::os::raw::c_int, pub co_framesize: ::std::os::raw::c_int, pub co_nlocals: ::std::os::raw::c_int, pub co_ncellvars: ::std::os::raw::c_int, pub co_nfreevars: ::std::os::raw::c_int, pub co_version: u32, pub co_localsplusnames: *mut PyObject, pub co_localspluskinds: *mut PyObject, pub co_filename: *mut PyObject, pub co_name: *mut PyObject, pub co_qualname: *mut PyObject, pub co_linetable: *mut PyObject, pub co_weakreflist: *mut PyObject, pub _co_cached: *mut _PyCoCached, pub _co_instrumentation_version: u64, pub _co_monitoring: *mut _PyCoMonitoringData, pub _co_firsttraceable: ::std::os::raw::c_int, pub co_extra: *mut ::std::os::raw::c_void, pub co_code_adaptive: [::std::os::raw::c_char; 1usize], } impl Default for PyCodeObject { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub const PyCodeEvent_PY_CODE_EVENT_CREATE: PyCodeEvent = 0; pub const PyCodeEvent_PY_CODE_EVENT_DESTROY: PyCodeEvent = 1; pub type PyCodeEvent = ::std::os::raw::c_uint; pub type PyCode_WatchCallback = ::std::option::Option< unsafe extern "C" fn(event: PyCodeEvent, co: *mut PyCodeObject) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Copy, Clone)] pub struct PySliceObject { pub ob_base: PyObject, pub start: *mut PyObject, pub stop: *mut PyObject, pub step: *mut PyObject, } impl Default for PySliceObject { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyWideStringList { pub length: Py_ssize_t, pub items: *mut *mut wchar_t, } impl Default for PyWideStringList { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct PyPreConfig { pub _config_init: ::std::os::raw::c_int, pub parse_argv: ::std::os::raw::c_int, pub isolated: ::std::os::raw::c_int, pub use_environment: ::std::os::raw::c_int, pub configure_locale: ::std::os::raw::c_int, pub coerce_c_locale: ::std::os::raw::c_int, pub coerce_c_locale_warn: ::std::os::raw::c_int, pub utf8_mode: ::std::os::raw::c_int, pub dev_mode: ::std::os::raw::c_int, pub allocator: ::std::os::raw::c_int, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyConfig { pub _config_init: ::std::os::raw::c_int, pub isolated: ::std::os::raw::c_int, pub use_environment: ::std::os::raw::c_int, pub dev_mode: ::std::os::raw::c_int, pub install_signal_handlers: ::std::os::raw::c_int, pub use_hash_seed: ::std::os::raw::c_int, pub hash_seed: ::std::os::raw::c_ulong, pub faulthandler: ::std::os::raw::c_int, pub tracemalloc: ::std::os::raw::c_int, pub perf_profiling: ::std::os::raw::c_int, pub import_time: ::std::os::raw::c_int, pub code_debug_ranges: ::std::os::raw::c_int, pub show_ref_count: ::std::os::raw::c_int, pub dump_refs: ::std::os::raw::c_int, pub dump_refs_file: *mut wchar_t, pub malloc_stats: ::std::os::raw::c_int, pub filesystem_encoding: *mut wchar_t, pub filesystem_errors: *mut wchar_t, pub pycache_prefix: *mut wchar_t, pub parse_argv: ::std::os::raw::c_int, pub orig_argv: PyWideStringList, pub argv: PyWideStringList, pub xoptions: PyWideStringList, pub warnoptions: PyWideStringList, pub site_import: ::std::os::raw::c_int, pub bytes_warning: ::std::os::raw::c_int, pub warn_default_encoding: ::std::os::raw::c_int, pub inspect: ::std::os::raw::c_int, pub interactive: ::std::os::raw::c_int, pub optimization_level: ::std::os::raw::c_int, pub parser_debug: ::std::os::raw::c_int, pub write_bytecode: ::std::os::raw::c_int, pub verbose: ::std::os::raw::c_int, pub quiet: ::std::os::raw::c_int, pub user_site_directory: ::std::os::raw::c_int, pub configure_c_stdio: ::std::os::raw::c_int, pub buffered_stdio: ::std::os::raw::c_int, pub stdio_encoding: *mut wchar_t, pub stdio_errors: *mut wchar_t, pub check_hash_pycs_mode: *mut wchar_t, pub use_frozen_modules: ::std::os::raw::c_int, pub safe_path: ::std::os::raw::c_int, pub int_max_str_digits: ::std::os::raw::c_int, pub pathconfig_warnings: ::std::os::raw::c_int, pub program_name: *mut wchar_t, pub pythonpath_env: *mut wchar_t, pub home: *mut wchar_t, pub platlibdir: *mut wchar_t, pub module_search_paths_set: ::std::os::raw::c_int, pub module_search_paths: PyWideStringList, pub stdlib_dir: *mut wchar_t, pub executable: *mut wchar_t, pub base_executable: *mut wchar_t, pub prefix: *mut wchar_t, pub base_prefix: *mut wchar_t, pub exec_prefix: *mut wchar_t, pub base_exec_prefix: *mut wchar_t, pub skip_source_first_line: ::std::os::raw::c_int, pub run_command: *mut wchar_t, pub run_module: *mut wchar_t, pub run_filename: *mut wchar_t, pub _install_importlib: ::std::os::raw::c_int, pub _init_main: ::std::os::raw::c_int, pub _is_python_build: ::std::os::raw::c_int, } impl Default for PyConfig { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type Py_tracefunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyFrameObject, arg3: ::std::os::raw::c_int, arg4: *mut PyObject, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _PyCFrame { pub current_frame: *mut _PyInterpreterFrame, pub previous: *mut _PyCFrame, } impl Default for _PyCFrame { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _err_stackitem { pub exc_value: *mut PyObject, pub previous_item: *mut _err_stackitem, } impl Default for _err_stackitem { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type _PyErr_StackItem = _err_stackitem; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _stack_chunk { pub previous: *mut _stack_chunk, pub size: usize, pub top: usize, pub data: [*mut PyObject; 1usize], } impl Default for _stack_chunk { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type _PyStackChunk = _stack_chunk; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _py_trashcan { pub delete_nesting: ::std::os::raw::c_int, pub delete_later: *mut PyObject, } impl Default for _py_trashcan { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _ts { pub prev: *mut PyThreadState, pub next: *mut PyThreadState, pub interp: *mut PyInterpreterState, pub _status: _ts__bindgen_ty_1, pub py_recursion_remaining: ::std::os::raw::c_int, pub py_recursion_limit: ::std::os::raw::c_int, pub c_recursion_remaining: ::std::os::raw::c_int, pub recursion_headroom: ::std::os::raw::c_int, pub tracing: ::std::os::raw::c_int, pub what_event: ::std::os::raw::c_int, pub cframe: *mut _PyCFrame, pub c_profilefunc: Py_tracefunc, pub c_tracefunc: Py_tracefunc, pub c_profileobj: *mut PyObject, pub c_traceobj: *mut PyObject, pub current_exception: *mut PyObject, pub exc_info: *mut _PyErr_StackItem, pub dict: *mut PyObject, pub gilstate_counter: ::std::os::raw::c_int, pub async_exc: *mut PyObject, pub thread_id: ::std::os::raw::c_ulong, pub native_thread_id: ::std::os::raw::c_ulong, pub trash: _py_trashcan, pub on_delete: ::std::option::Option, pub on_delete_data: *mut ::std::os::raw::c_void, pub coroutine_origin_tracking_depth: ::std::os::raw::c_int, pub async_gen_firstiter: *mut PyObject, pub async_gen_finalizer: *mut PyObject, pub context: *mut PyObject, pub context_ver: u64, pub id: u64, pub datastack_chunk: *mut _PyStackChunk, pub datastack_top: *mut *mut PyObject, pub datastack_limit: *mut *mut PyObject, pub exc_state: _PyErr_StackItem, pub root_cframe: _PyCFrame, } #[repr(C)] #[repr(align(4))] #[derive(Debug, Default, Copy, Clone)] pub struct _ts__bindgen_ty_1 { pub _bitfield_align_1: [u8; 0], pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, } impl _ts__bindgen_ty_1 { #[inline] pub fn initialized(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } } #[inline] pub fn set_initialized(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(0usize, 1u8, val as u64) } } #[inline] pub unsafe fn initialized_raw(this: *const Self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( ::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8, ) as u32) } } #[inline] pub unsafe fn set_initialized_raw(this: *mut Self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( ::std::ptr::addr_of_mut!((*this)._bitfield_1), 0usize, 1u8, val as u64, ) } } #[inline] pub fn bound(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } } #[inline] pub fn set_bound(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(1usize, 1u8, val as u64) } } #[inline] pub unsafe fn bound_raw(this: *const Self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( ::std::ptr::addr_of!((*this)._bitfield_1), 1usize, 1u8, ) as u32) } } #[inline] pub unsafe fn set_bound_raw(this: *mut Self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( ::std::ptr::addr_of_mut!((*this)._bitfield_1), 1usize, 1u8, val as u64, ) } } #[inline] pub fn unbound(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } } #[inline] pub fn set_unbound(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(2usize, 1u8, val as u64) } } #[inline] pub unsafe fn unbound_raw(this: *const Self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( ::std::ptr::addr_of!((*this)._bitfield_1), 2usize, 1u8, ) as u32) } } #[inline] pub unsafe fn set_unbound_raw(this: *mut Self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( ::std::ptr::addr_of_mut!((*this)._bitfield_1), 2usize, 1u8, val as u64, ) } } #[inline] pub fn bound_gilstate(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } } #[inline] pub fn set_bound_gilstate(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(3usize, 1u8, val as u64) } } #[inline] pub unsafe fn bound_gilstate_raw(this: *const Self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( ::std::ptr::addr_of!((*this)._bitfield_1), 3usize, 1u8, ) as u32) } } #[inline] pub unsafe fn set_bound_gilstate_raw(this: *mut Self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( ::std::ptr::addr_of_mut!((*this)._bitfield_1), 3usize, 1u8, val as u64, ) } } #[inline] pub fn active(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } } #[inline] pub fn set_active(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(4usize, 1u8, val as u64) } } #[inline] pub unsafe fn active_raw(this: *const Self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( ::std::ptr::addr_of!((*this)._bitfield_1), 4usize, 1u8, ) as u32) } } #[inline] pub unsafe fn set_active_raw(this: *mut Self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( ::std::ptr::addr_of_mut!((*this)._bitfield_1), 4usize, 1u8, val as u64, ) } } #[inline] pub fn finalizing(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } } #[inline] pub fn set_finalizing(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(5usize, 1u8, val as u64) } } #[inline] pub unsafe fn finalizing_raw(this: *const Self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( ::std::ptr::addr_of!((*this)._bitfield_1), 5usize, 1u8, ) as u32) } } #[inline] pub unsafe fn set_finalizing_raw(this: *mut Self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( ::std::ptr::addr_of_mut!((*this)._bitfield_1), 5usize, 1u8, val as u64, ) } } #[inline] pub fn cleared(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } } #[inline] pub fn set_cleared(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(6usize, 1u8, val as u64) } } #[inline] pub unsafe fn cleared_raw(this: *const Self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( ::std::ptr::addr_of!((*this)._bitfield_1), 6usize, 1u8, ) as u32) } } #[inline] pub unsafe fn set_cleared_raw(this: *mut Self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( ::std::ptr::addr_of_mut!((*this)._bitfield_1), 6usize, 1u8, val as u64, ) } } #[inline] pub fn finalized(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } } #[inline] pub fn set_finalized(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(7usize, 1u8, val as u64) } } #[inline] pub unsafe fn finalized_raw(this: *const Self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( ::std::ptr::addr_of!((*this)._bitfield_1), 7usize, 1u8, ) as u32) } } #[inline] pub unsafe fn set_finalized_raw(this: *mut Self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( ::std::ptr::addr_of_mut!((*this)._bitfield_1), 7usize, 1u8, val as u64, ) } } #[inline] pub fn new_bitfield_1( initialized: ::std::os::raw::c_uint, bound: ::std::os::raw::c_uint, unbound: ::std::os::raw::c_uint, bound_gilstate: ::std::os::raw::c_uint, active: ::std::os::raw::c_uint, finalizing: ::std::os::raw::c_uint, cleared: ::std::os::raw::c_uint, finalized: ::std::os::raw::c_uint, ) -> __BindgenBitfieldUnit<[u8; 4usize]> { let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); __bindgen_bitfield_unit.set(0usize, 1u8, { let initialized: u32 = unsafe { ::std::mem::transmute(initialized) }; initialized as u64 }); __bindgen_bitfield_unit.set(1usize, 1u8, { let bound: u32 = unsafe { ::std::mem::transmute(bound) }; bound as u64 }); __bindgen_bitfield_unit.set(2usize, 1u8, { let unbound: u32 = unsafe { ::std::mem::transmute(unbound) }; unbound as u64 }); __bindgen_bitfield_unit.set(3usize, 1u8, { let bound_gilstate: u32 = unsafe { ::std::mem::transmute(bound_gilstate) }; bound_gilstate as u64 }); __bindgen_bitfield_unit.set(4usize, 1u8, { let active: u32 = unsafe { ::std::mem::transmute(active) }; active as u64 }); __bindgen_bitfield_unit.set(5usize, 1u8, { let finalizing: u32 = unsafe { ::std::mem::transmute(finalizing) }; finalizing as u64 }); __bindgen_bitfield_unit.set(6usize, 1u8, { let cleared: u32 = unsafe { ::std::mem::transmute(cleared) }; cleared as u64 }); __bindgen_bitfield_unit.set(7usize, 1u8, { let finalized: u32 = unsafe { ::std::mem::transmute(finalized) }; finalized as u64 }); __bindgen_bitfield_unit } } impl Default for _ts { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type _PyFrameEvalFunction = ::std::option::Option< unsafe extern "C" fn( tstate: *mut PyThreadState, arg1: *mut _PyInterpreterFrame, arg2: ::std::os::raw::c_int, ) -> *mut PyObject, >; pub type _PyCrossInterpreterData = _xid; pub type xid_newobjectfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut _PyCrossInterpreterData) -> *mut PyObject, >; pub type xid_freefunc = ::std::option::Option; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _xid { pub data: *mut ::std::os::raw::c_void, pub obj: *mut PyObject, pub interp: i64, pub new_object: xid_newobjectfunc, pub free: xid_freefunc, } impl Default for _xid { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type crossinterpdatafunc = ::std::option::Option< unsafe extern "C" fn( tstate: *mut PyThreadState, arg1: *mut PyObject, arg2: *mut _PyCrossInterpreterData, ) -> ::std::os::raw::c_int, >; pub type getter = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_void) -> *mut PyObject, >; pub type setter = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyGetSetDef { pub name: *const ::std::os::raw::c_char, pub get: getter, pub set: setter, pub doc: *const ::std::os::raw::c_char, pub closure: *mut ::std::os::raw::c_void, } impl Default for PyGetSetDef { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyMemberDef { pub name: *const ::std::os::raw::c_char, pub type_: ::std::os::raw::c_int, pub offset: Py_ssize_t, pub flags: ::std::os::raw::c_int, pub doc: *const ::std::os::raw::c_char, } impl Default for PyMemberDef { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type wrapperfunc = ::std::option::Option< unsafe extern "C" fn( self_: *mut PyObject, args: *mut PyObject, wrapped: *mut ::std::os::raw::c_void, ) -> *mut PyObject, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct wrapperbase { pub name: *const ::std::os::raw::c_char, pub offset: ::std::os::raw::c_int, pub function: *mut ::std::os::raw::c_void, pub wrapper: wrapperfunc, pub doc: *const ::std::os::raw::c_char, pub flags: ::std::os::raw::c_int, pub name_strobj: *mut PyObject, } impl Default for wrapperbase { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type _PyTime_t = i64; #[repr(C)] #[derive(Copy, Clone)] pub struct PyBaseExceptionObject { pub ob_base: PyObject, pub dict: *mut PyObject, pub args: *mut PyObject, pub notes: *mut PyObject, pub traceback: *mut PyObject, pub context: *mut PyObject, pub cause: *mut PyObject, pub suppress_context: ::std::os::raw::c_char, } impl Default for PyBaseExceptionObject { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type PyThread_type_lock = *mut ::std::os::raw::c_void; pub type Py_tss_t = _Py_tss_t; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_tss_t { pub _is_initialized: ::std::os::raw::c_int, pub _key: pthread_key_t, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _PyArg_Parser { pub initialized: ::std::os::raw::c_int, pub format: *const ::std::os::raw::c_char, pub keywords: *const *const ::std::os::raw::c_char, pub fname: *const ::std::os::raw::c_char, pub custom_msg: *const ::std::os::raw::c_char, pub pos: ::std::os::raw::c_int, pub min: ::std::os::raw::c_int, pub max: ::std::os::raw::c_int, pub kwtuple: *mut PyObject, pub next: *mut _PyArg_Parser, } impl Default for _PyArg_Parser { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type atexit_datacallbackfunc = ::std::option::Option; pub type Py_AuditHookFunction = ::std::option::Option< unsafe extern "C" fn( arg1: *const ::std::os::raw::c_char, arg2: *mut PyObject, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _inittab { pub name: *const ::std::os::raw::c_char, pub initfunc: ::std::option::Option *mut PyObject>, } impl Default for _inittab { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct ast_state { pub initialized: ::std::os::raw::c_int, pub recursion_depth: ::std::os::raw::c_int, pub recursion_limit: ::std::os::raw::c_int, pub AST_type: *mut PyObject, pub Add_singleton: *mut PyObject, pub Add_type: *mut PyObject, pub And_singleton: *mut PyObject, pub And_type: *mut PyObject, pub AnnAssign_type: *mut PyObject, pub Assert_type: *mut PyObject, pub Assign_type: *mut PyObject, pub AsyncFor_type: *mut PyObject, pub AsyncFunctionDef_type: *mut PyObject, pub AsyncWith_type: *mut PyObject, pub Attribute_type: *mut PyObject, pub AugAssign_type: *mut PyObject, pub Await_type: *mut PyObject, pub BinOp_type: *mut PyObject, pub BitAnd_singleton: *mut PyObject, pub BitAnd_type: *mut PyObject, pub BitOr_singleton: *mut PyObject, pub BitOr_type: *mut PyObject, pub BitXor_singleton: *mut PyObject, pub BitXor_type: *mut PyObject, pub BoolOp_type: *mut PyObject, pub Break_type: *mut PyObject, pub Call_type: *mut PyObject, pub ClassDef_type: *mut PyObject, pub Compare_type: *mut PyObject, pub Constant_type: *mut PyObject, pub Continue_type: *mut PyObject, pub Del_singleton: *mut PyObject, pub Del_type: *mut PyObject, pub Delete_type: *mut PyObject, pub DictComp_type: *mut PyObject, pub Dict_type: *mut PyObject, pub Div_singleton: *mut PyObject, pub Div_type: *mut PyObject, pub Eq_singleton: *mut PyObject, pub Eq_type: *mut PyObject, pub ExceptHandler_type: *mut PyObject, pub Expr_type: *mut PyObject, pub Expression_type: *mut PyObject, pub FloorDiv_singleton: *mut PyObject, pub FloorDiv_type: *mut PyObject, pub For_type: *mut PyObject, pub FormattedValue_type: *mut PyObject, pub FunctionDef_type: *mut PyObject, pub FunctionType_type: *mut PyObject, pub GeneratorExp_type: *mut PyObject, pub Global_type: *mut PyObject, pub GtE_singleton: *mut PyObject, pub GtE_type: *mut PyObject, pub Gt_singleton: *mut PyObject, pub Gt_type: *mut PyObject, pub IfExp_type: *mut PyObject, pub If_type: *mut PyObject, pub ImportFrom_type: *mut PyObject, pub Import_type: *mut PyObject, pub In_singleton: *mut PyObject, pub In_type: *mut PyObject, pub Interactive_type: *mut PyObject, pub Invert_singleton: *mut PyObject, pub Invert_type: *mut PyObject, pub IsNot_singleton: *mut PyObject, pub IsNot_type: *mut PyObject, pub Is_singleton: *mut PyObject, pub Is_type: *mut PyObject, pub JoinedStr_type: *mut PyObject, pub LShift_singleton: *mut PyObject, pub LShift_type: *mut PyObject, pub Lambda_type: *mut PyObject, pub ListComp_type: *mut PyObject, pub List_type: *mut PyObject, pub Load_singleton: *mut PyObject, pub Load_type: *mut PyObject, pub LtE_singleton: *mut PyObject, pub LtE_type: *mut PyObject, pub Lt_singleton: *mut PyObject, pub Lt_type: *mut PyObject, pub MatMult_singleton: *mut PyObject, pub MatMult_type: *mut PyObject, pub MatchAs_type: *mut PyObject, pub MatchClass_type: *mut PyObject, pub MatchMapping_type: *mut PyObject, pub MatchOr_type: *mut PyObject, pub MatchSequence_type: *mut PyObject, pub MatchSingleton_type: *mut PyObject, pub MatchStar_type: *mut PyObject, pub MatchValue_type: *mut PyObject, pub Match_type: *mut PyObject, pub Mod_singleton: *mut PyObject, pub Mod_type: *mut PyObject, pub Module_type: *mut PyObject, pub Mult_singleton: *mut PyObject, pub Mult_type: *mut PyObject, pub Name_type: *mut PyObject, pub NamedExpr_type: *mut PyObject, pub Nonlocal_type: *mut PyObject, pub NotEq_singleton: *mut PyObject, pub NotEq_type: *mut PyObject, pub NotIn_singleton: *mut PyObject, pub NotIn_type: *mut PyObject, pub Not_singleton: *mut PyObject, pub Not_type: *mut PyObject, pub Or_singleton: *mut PyObject, pub Or_type: *mut PyObject, pub ParamSpec_type: *mut PyObject, pub Pass_type: *mut PyObject, pub Pow_singleton: *mut PyObject, pub Pow_type: *mut PyObject, pub RShift_singleton: *mut PyObject, pub RShift_type: *mut PyObject, pub Raise_type: *mut PyObject, pub Return_type: *mut PyObject, pub SetComp_type: *mut PyObject, pub Set_type: *mut PyObject, pub Slice_type: *mut PyObject, pub Starred_type: *mut PyObject, pub Store_singleton: *mut PyObject, pub Store_type: *mut PyObject, pub Sub_singleton: *mut PyObject, pub Sub_type: *mut PyObject, pub Subscript_type: *mut PyObject, pub TryStar_type: *mut PyObject, pub Try_type: *mut PyObject, pub Tuple_type: *mut PyObject, pub TypeAlias_type: *mut PyObject, pub TypeIgnore_type: *mut PyObject, pub TypeVarTuple_type: *mut PyObject, pub TypeVar_type: *mut PyObject, pub UAdd_singleton: *mut PyObject, pub UAdd_type: *mut PyObject, pub USub_singleton: *mut PyObject, pub USub_type: *mut PyObject, pub UnaryOp_type: *mut PyObject, pub While_type: *mut PyObject, pub With_type: *mut PyObject, pub YieldFrom_type: *mut PyObject, pub Yield_type: *mut PyObject, pub __dict__: *mut PyObject, pub __doc__: *mut PyObject, pub __match_args__: *mut PyObject, pub __module__: *mut PyObject, pub _attributes: *mut PyObject, pub _fields: *mut PyObject, pub alias_type: *mut PyObject, pub annotation: *mut PyObject, pub arg: *mut PyObject, pub arg_type: *mut PyObject, pub args: *mut PyObject, pub argtypes: *mut PyObject, pub arguments_type: *mut PyObject, pub asname: *mut PyObject, pub ast: *mut PyObject, pub attr: *mut PyObject, pub bases: *mut PyObject, pub body: *mut PyObject, pub boolop_type: *mut PyObject, pub bound: *mut PyObject, pub cases: *mut PyObject, pub cause: *mut PyObject, pub cls: *mut PyObject, pub cmpop_type: *mut PyObject, pub col_offset: *mut PyObject, pub comparators: *mut PyObject, pub comprehension_type: *mut PyObject, pub context_expr: *mut PyObject, pub conversion: *mut PyObject, pub ctx: *mut PyObject, pub decorator_list: *mut PyObject, pub defaults: *mut PyObject, pub elt: *mut PyObject, pub elts: *mut PyObject, pub end_col_offset: *mut PyObject, pub end_lineno: *mut PyObject, pub exc: *mut PyObject, pub excepthandler_type: *mut PyObject, pub expr_context_type: *mut PyObject, pub expr_type: *mut PyObject, pub finalbody: *mut PyObject, pub format_spec: *mut PyObject, pub func: *mut PyObject, pub generators: *mut PyObject, pub guard: *mut PyObject, pub handlers: *mut PyObject, pub id: *mut PyObject, pub ifs: *mut PyObject, pub is_async: *mut PyObject, pub items: *mut PyObject, pub iter: *mut PyObject, pub key: *mut PyObject, pub keys: *mut PyObject, pub keyword_type: *mut PyObject, pub keywords: *mut PyObject, pub kind: *mut PyObject, pub kw_defaults: *mut PyObject, pub kwarg: *mut PyObject, pub kwd_attrs: *mut PyObject, pub kwd_patterns: *mut PyObject, pub kwonlyargs: *mut PyObject, pub left: *mut PyObject, pub level: *mut PyObject, pub lineno: *mut PyObject, pub lower: *mut PyObject, pub match_case_type: *mut PyObject, pub mod_type: *mut PyObject, pub module: *mut PyObject, pub msg: *mut PyObject, pub name: *mut PyObject, pub names: *mut PyObject, pub op: *mut PyObject, pub operand: *mut PyObject, pub operator_type: *mut PyObject, pub ops: *mut PyObject, pub optional_vars: *mut PyObject, pub orelse: *mut PyObject, pub pattern: *mut PyObject, pub pattern_type: *mut PyObject, pub patterns: *mut PyObject, pub posonlyargs: *mut PyObject, pub rest: *mut PyObject, pub returns: *mut PyObject, pub right: *mut PyObject, pub simple: *mut PyObject, pub slice: *mut PyObject, pub step: *mut PyObject, pub stmt_type: *mut PyObject, pub subject: *mut PyObject, pub tag: *mut PyObject, pub target: *mut PyObject, pub targets: *mut PyObject, pub test: *mut PyObject, pub type_: *mut PyObject, pub type_comment: *mut PyObject, pub type_ignore_type: *mut PyObject, pub type_ignores: *mut PyObject, pub type_param_type: *mut PyObject, pub type_params: *mut PyObject, pub unaryop_type: *mut PyObject, pub upper: *mut PyObject, pub value: *mut PyObject, pub values: *mut PyObject, pub vararg: *mut PyObject, pub withitem_type: *mut PyObject, } impl Default for ast_state { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type atexit_callbackfunc = ::std::option::Option; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _atexit_runtime_state { pub mutex: PyThread_type_lock, pub callbacks: [atexit_callbackfunc; 32usize], pub ncallbacks: ::std::os::raw::c_int, } impl Default for _atexit_runtime_state { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct atexit_callback { pub func: atexit_datacallbackfunc, pub data: *mut ::std::os::raw::c_void, pub next: *mut atexit_callback, } impl Default for atexit_callback { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct atexit_py_callback { pub func: *mut PyObject, pub args: *mut PyObject, pub kwargs: *mut PyObject, } impl Default for atexit_py_callback { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct atexit_state { pub ll_callbacks: *mut atexit_callback, pub last_ll_callback: *mut atexit_callback, pub callbacks: *mut *mut atexit_py_callback, pub ncallbacks: ::std::os::raw::c_int, pub callback_len: ::std::os::raw::c_int, } impl Default for atexit_state { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_atomic_address { pub _value: usize, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_atomic_int { pub _value: ::std::os::raw::c_int, } #[repr(C)] #[derive(Copy, Clone)] pub struct _gil_runtime_state { pub interval: ::std::os::raw::c_ulong, pub last_holder: _Py_atomic_address, pub locked: _Py_atomic_int, pub switch_number: ::std::os::raw::c_ulong, pub cond: pthread_cond_t, pub mutex: pthread_mutex_t, pub switch_cond: pthread_cond_t, pub switch_mutex: pthread_mutex_t, } impl Default for _gil_runtime_state { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _pending_calls { pub busy: ::std::os::raw::c_int, pub lock: PyThread_type_lock, pub calls_to_do: _Py_atomic_int, pub async_exc: ::std::os::raw::c_int, pub calls: [_pending_calls__pending_call; 32usize], pub first: ::std::os::raw::c_int, pub last: ::std::os::raw::c_int, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _pending_calls__pending_call { pub func: ::std::option::Option< unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, >, pub arg: *mut ::std::os::raw::c_void, } impl Default for _pending_calls__pending_call { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } impl Default for _pending_calls { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _ceval_runtime_state { pub perf: _ceval_runtime_state__bindgen_ty_1, pub signals_pending: _Py_atomic_int, pub pending_mainthread: _pending_calls, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _ceval_runtime_state__bindgen_ty_1 { pub _not_used: ::std::os::raw::c_int, } impl Default for _ceval_runtime_state { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _ceval_state { pub eval_breaker: _Py_atomic_int, pub gil_drop_request: _Py_atomic_int, pub recursion_limit: ::std::os::raw::c_int, pub gil: *mut _gil_runtime_state, pub own_gil: ::std::os::raw::c_int, pub gc_scheduled: _Py_atomic_int, pub pending: _pending_calls, } impl Default for _ceval_state { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct callable_cache { pub isinstance: *mut PyObject, pub len: *mut PyObject, pub list_append: *mut PyObject, pub object__getattribute__: *mut PyObject, } impl Default for callable_cache { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct PyHamtNode { pub ob_base: PyObject, } impl Default for PyHamtNode { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct PyHamtObject { pub ob_base: PyObject, pub h_root: *mut PyHamtNode, pub h_weakreflist: *mut PyObject, pub h_count: Py_ssize_t, } impl Default for PyHamtObject { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct PyHamtNode_Bitmap { pub ob_base: PyVarObject, pub b_bitmap: u32, pub b_array: [*mut PyObject; 1usize], } impl Default for PyHamtNode_Bitmap { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _PyContextTokenMissing { pub ob_base: PyObject, } impl Default for _PyContextTokenMissing { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_context_state {} #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_dict_state { pub global_version: u64, pub next_keys_version: u32, pub watchers: [PyDict_WatchCallback; 8usize], } pub type ULong = u32; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct Bigint { pub next: *mut Bigint, pub k: ::std::os::raw::c_int, pub maxwds: ::std::os::raw::c_int, pub sign: ::std::os::raw::c_int, pub wds: ::std::os::raw::c_int, pub x: [ULong; 1usize], } impl Default for Bigint { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _dtoa_state { pub p5s: *mut Bigint, pub freelist: [*mut Bigint; 8usize], pub preallocated: [f64; 288usize], pub preallocated_next: *mut f64, } impl Default for _dtoa_state { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_exc_state { pub errnomap: *mut PyObject, pub memerrors_freelist: *mut PyBaseExceptionObject, pub memerrors_numfree: ::std::os::raw::c_int, pub PyExc_ExceptionGroup: *mut PyObject, } impl Default for _Py_exc_state { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub const _py_float_format_type__py_float_format_unknown: _py_float_format_type = 0; pub const _py_float_format_type__py_float_format_ieee_big_endian: _py_float_format_type = 1; pub const _py_float_format_type__py_float_format_ieee_little_endian: _py_float_format_type = 2; pub type _py_float_format_type = ::std::os::raw::c_uint; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_float_runtime_state { pub float_format: _py_float_format_type, pub double_format: _py_float_format_type, } impl Default for _Py_float_runtime_state { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_float_state {} #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _py_func_state { pub next_version: u32, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_async_gen_state {} #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct PyGC_Head { pub _gc_next: usize, pub _gc_prev: usize, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct gc_generation { pub head: PyGC_Head, pub threshold: ::std::os::raw::c_int, pub count: ::std::os::raw::c_int, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct gc_generation_stats { pub collections: Py_ssize_t, pub collected: Py_ssize_t, pub uncollectable: Py_ssize_t, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _gc_runtime_state { pub trash_delete_later: *mut PyObject, pub trash_delete_nesting: ::std::os::raw::c_int, pub enabled: ::std::os::raw::c_int, pub debug: ::std::os::raw::c_int, pub generations: [gc_generation; 3usize], pub generation0: *mut PyGC_Head, pub permanent_generation: gc_generation, pub generation_stats: [gc_generation_stats; 3usize], pub collecting: ::std::os::raw::c_int, pub garbage: *mut PyObject, pub callbacks: *mut PyObject, pub long_lived_total: Py_ssize_t, pub long_lived_pending: Py_ssize_t, } impl Default for _gc_runtime_state { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings { pub literals: _Py_global_strings__bindgen_ty_1, pub identifiers: _Py_global_strings__bindgen_ty_2, pub ascii: [_Py_global_strings__bindgen_ty_3; 128usize], pub latin1: [_Py_global_strings__bindgen_ty_4; 128usize], } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1 { pub _py_anon_dictcomp: _Py_global_strings__bindgen_ty_1__bindgen_ty_1, pub _py_anon_genexpr: _Py_global_strings__bindgen_ty_1__bindgen_ty_2, pub _py_anon_lambda: _Py_global_strings__bindgen_ty_1__bindgen_ty_3, pub _py_anon_listcomp: _Py_global_strings__bindgen_ty_1__bindgen_ty_4, pub _py_anon_module: _Py_global_strings__bindgen_ty_1__bindgen_ty_5, pub _py_anon_setcomp: _Py_global_strings__bindgen_ty_1__bindgen_ty_6, pub _py_anon_string: _Py_global_strings__bindgen_ty_1__bindgen_ty_7, pub _py_anon_unknown: _Py_global_strings__bindgen_ty_1__bindgen_ty_8, pub _py_close_br: _Py_global_strings__bindgen_ty_1__bindgen_ty_9, pub _py_dbl_close_br: _Py_global_strings__bindgen_ty_1__bindgen_ty_10, pub _py_dbl_open_br: _Py_global_strings__bindgen_ty_1__bindgen_ty_11, pub _py_dbl_percent: _Py_global_strings__bindgen_ty_1__bindgen_ty_12, pub _py_defaults: _Py_global_strings__bindgen_ty_1__bindgen_ty_13, pub _py_dot: _Py_global_strings__bindgen_ty_1__bindgen_ty_14, pub _py_dot_locals: _Py_global_strings__bindgen_ty_1__bindgen_ty_15, pub _py_empty: _Py_global_strings__bindgen_ty_1__bindgen_ty_16, pub _py_generic_base: _Py_global_strings__bindgen_ty_1__bindgen_ty_17, pub _py_json_decoder: _Py_global_strings__bindgen_ty_1__bindgen_ty_18, pub _py_kwdefaults: _Py_global_strings__bindgen_ty_1__bindgen_ty_19, pub _py_list_err: _Py_global_strings__bindgen_ty_1__bindgen_ty_20, pub _py_newline: _Py_global_strings__bindgen_ty_1__bindgen_ty_21, pub _py_open_br: _Py_global_strings__bindgen_ty_1__bindgen_ty_22, pub _py_percent: _Py_global_strings__bindgen_ty_1__bindgen_ty_23, pub _py_shim_name: _Py_global_strings__bindgen_ty_1__bindgen_ty_24, pub _py_type_params: _Py_global_strings__bindgen_ty_1__bindgen_ty_25, pub _py_utf_8: _Py_global_strings__bindgen_ty_1__bindgen_ty_26, } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_1 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_2 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_2 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_3 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_3 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_4 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_4 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_5 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_5 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_6 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_6 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_7 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_7 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_8 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_8 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_9 { pub _ascii: PyASCIIObject, pub _data: [u8; 2usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_9 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_10 { pub _ascii: PyASCIIObject, pub _data: [u8; 3usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_10 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_11 { pub _ascii: PyASCIIObject, pub _data: [u8; 3usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_11 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_12 { pub _ascii: PyASCIIObject, pub _data: [u8; 3usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_12 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_13 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_13 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_14 { pub _ascii: PyASCIIObject, pub _data: [u8; 2usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_14 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_15 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_15 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_16 { pub _ascii: PyASCIIObject, pub _data: [u8; 1usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_16 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_17 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_17 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_18 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_18 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_19 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_19 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_20 { pub _ascii: PyASCIIObject, pub _data: [u8; 24usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_20 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_21 { pub _ascii: PyASCIIObject, pub _data: [u8; 2usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_21 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_22 { pub _ascii: PyASCIIObject, pub _data: [u8; 2usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_22 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_23 { pub _ascii: PyASCIIObject, pub _data: [u8; 2usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_23 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_24 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_24 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_25 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_25 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_26 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_26 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } impl Default for _Py_global_strings__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2 { pub _py_CANCELLED: _Py_global_strings__bindgen_ty_2__bindgen_ty_1, pub _py_FINISHED: _Py_global_strings__bindgen_ty_2__bindgen_ty_2, pub _py_False: _Py_global_strings__bindgen_ty_2__bindgen_ty_3, pub _py_JSONDecodeError: _Py_global_strings__bindgen_ty_2__bindgen_ty_4, pub _py_PENDING: _Py_global_strings__bindgen_ty_2__bindgen_ty_5, pub _py_Py_Repr: _Py_global_strings__bindgen_ty_2__bindgen_ty_6, pub _py_TextIOWrapper: _Py_global_strings__bindgen_ty_2__bindgen_ty_7, pub _py_True: _Py_global_strings__bindgen_ty_2__bindgen_ty_8, pub _py_WarningMessage: _Py_global_strings__bindgen_ty_2__bindgen_ty_9, pub _py__: _Py_global_strings__bindgen_ty_2__bindgen_ty_10, pub _py__WindowsConsoleIO: _Py_global_strings__bindgen_ty_2__bindgen_ty_11, pub _py___IOBase_closed: _Py_global_strings__bindgen_ty_2__bindgen_ty_12, pub _py___abc_tpflags__: _Py_global_strings__bindgen_ty_2__bindgen_ty_13, pub _py___abs__: _Py_global_strings__bindgen_ty_2__bindgen_ty_14, pub _py___abstractmethods__: _Py_global_strings__bindgen_ty_2__bindgen_ty_15, pub _py___add__: _Py_global_strings__bindgen_ty_2__bindgen_ty_16, pub _py___aenter__: _Py_global_strings__bindgen_ty_2__bindgen_ty_17, pub _py___aexit__: _Py_global_strings__bindgen_ty_2__bindgen_ty_18, pub _py___aiter__: _Py_global_strings__bindgen_ty_2__bindgen_ty_19, pub _py___all__: _Py_global_strings__bindgen_ty_2__bindgen_ty_20, pub _py___and__: _Py_global_strings__bindgen_ty_2__bindgen_ty_21, pub _py___anext__: _Py_global_strings__bindgen_ty_2__bindgen_ty_22, pub _py___annotations__: _Py_global_strings__bindgen_ty_2__bindgen_ty_23, pub _py___args__: _Py_global_strings__bindgen_ty_2__bindgen_ty_24, pub _py___asyncio_running_event_loop__: _Py_global_strings__bindgen_ty_2__bindgen_ty_25, pub _py___await__: _Py_global_strings__bindgen_ty_2__bindgen_ty_26, pub _py___bases__: _Py_global_strings__bindgen_ty_2__bindgen_ty_27, pub _py___bool__: _Py_global_strings__bindgen_ty_2__bindgen_ty_28, pub _py___buffer__: _Py_global_strings__bindgen_ty_2__bindgen_ty_29, pub _py___build_class__: _Py_global_strings__bindgen_ty_2__bindgen_ty_30, pub _py___builtins__: _Py_global_strings__bindgen_ty_2__bindgen_ty_31, pub _py___bytes__: _Py_global_strings__bindgen_ty_2__bindgen_ty_32, pub _py___call__: _Py_global_strings__bindgen_ty_2__bindgen_ty_33, pub _py___cantrace__: _Py_global_strings__bindgen_ty_2__bindgen_ty_34, pub _py___class__: _Py_global_strings__bindgen_ty_2__bindgen_ty_35, pub _py___class_getitem__: _Py_global_strings__bindgen_ty_2__bindgen_ty_36, pub _py___classcell__: _Py_global_strings__bindgen_ty_2__bindgen_ty_37, pub _py___classdict__: _Py_global_strings__bindgen_ty_2__bindgen_ty_38, pub _py___classdictcell__: _Py_global_strings__bindgen_ty_2__bindgen_ty_39, pub _py___complex__: _Py_global_strings__bindgen_ty_2__bindgen_ty_40, pub _py___contains__: _Py_global_strings__bindgen_ty_2__bindgen_ty_41, pub _py___copy__: _Py_global_strings__bindgen_ty_2__bindgen_ty_42, pub _py___ctypes_from_outparam__: _Py_global_strings__bindgen_ty_2__bindgen_ty_43, pub _py___del__: _Py_global_strings__bindgen_ty_2__bindgen_ty_44, pub _py___delattr__: _Py_global_strings__bindgen_ty_2__bindgen_ty_45, pub _py___delete__: _Py_global_strings__bindgen_ty_2__bindgen_ty_46, pub _py___delitem__: _Py_global_strings__bindgen_ty_2__bindgen_ty_47, pub _py___dict__: _Py_global_strings__bindgen_ty_2__bindgen_ty_48, pub _py___dictoffset__: _Py_global_strings__bindgen_ty_2__bindgen_ty_49, pub _py___dir__: _Py_global_strings__bindgen_ty_2__bindgen_ty_50, pub _py___divmod__: _Py_global_strings__bindgen_ty_2__bindgen_ty_51, pub _py___doc__: _Py_global_strings__bindgen_ty_2__bindgen_ty_52, pub _py___enter__: _Py_global_strings__bindgen_ty_2__bindgen_ty_53, pub _py___eq__: _Py_global_strings__bindgen_ty_2__bindgen_ty_54, pub _py___exit__: _Py_global_strings__bindgen_ty_2__bindgen_ty_55, pub _py___file__: _Py_global_strings__bindgen_ty_2__bindgen_ty_56, pub _py___float__: _Py_global_strings__bindgen_ty_2__bindgen_ty_57, pub _py___floordiv__: _Py_global_strings__bindgen_ty_2__bindgen_ty_58, pub _py___format__: _Py_global_strings__bindgen_ty_2__bindgen_ty_59, pub _py___fspath__: _Py_global_strings__bindgen_ty_2__bindgen_ty_60, pub _py___ge__: _Py_global_strings__bindgen_ty_2__bindgen_ty_61, pub _py___get__: _Py_global_strings__bindgen_ty_2__bindgen_ty_62, pub _py___getattr__: _Py_global_strings__bindgen_ty_2__bindgen_ty_63, pub _py___getattribute__: _Py_global_strings__bindgen_ty_2__bindgen_ty_64, pub _py___getinitargs__: _Py_global_strings__bindgen_ty_2__bindgen_ty_65, pub _py___getitem__: _Py_global_strings__bindgen_ty_2__bindgen_ty_66, pub _py___getnewargs__: _Py_global_strings__bindgen_ty_2__bindgen_ty_67, pub _py___getnewargs_ex__: _Py_global_strings__bindgen_ty_2__bindgen_ty_68, pub _py___getstate__: _Py_global_strings__bindgen_ty_2__bindgen_ty_69, pub _py___gt__: _Py_global_strings__bindgen_ty_2__bindgen_ty_70, pub _py___hash__: _Py_global_strings__bindgen_ty_2__bindgen_ty_71, pub _py___iadd__: _Py_global_strings__bindgen_ty_2__bindgen_ty_72, pub _py___iand__: _Py_global_strings__bindgen_ty_2__bindgen_ty_73, pub _py___ifloordiv__: _Py_global_strings__bindgen_ty_2__bindgen_ty_74, pub _py___ilshift__: _Py_global_strings__bindgen_ty_2__bindgen_ty_75, pub _py___imatmul__: _Py_global_strings__bindgen_ty_2__bindgen_ty_76, pub _py___imod__: _Py_global_strings__bindgen_ty_2__bindgen_ty_77, pub _py___import__: _Py_global_strings__bindgen_ty_2__bindgen_ty_78, pub _py___imul__: _Py_global_strings__bindgen_ty_2__bindgen_ty_79, pub _py___index__: _Py_global_strings__bindgen_ty_2__bindgen_ty_80, pub _py___init__: _Py_global_strings__bindgen_ty_2__bindgen_ty_81, pub _py___init_subclass__: _Py_global_strings__bindgen_ty_2__bindgen_ty_82, pub _py___instancecheck__: _Py_global_strings__bindgen_ty_2__bindgen_ty_83, pub _py___int__: _Py_global_strings__bindgen_ty_2__bindgen_ty_84, pub _py___invert__: _Py_global_strings__bindgen_ty_2__bindgen_ty_85, pub _py___ior__: _Py_global_strings__bindgen_ty_2__bindgen_ty_86, pub _py___ipow__: _Py_global_strings__bindgen_ty_2__bindgen_ty_87, pub _py___irshift__: _Py_global_strings__bindgen_ty_2__bindgen_ty_88, pub _py___isabstractmethod__: _Py_global_strings__bindgen_ty_2__bindgen_ty_89, pub _py___isub__: _Py_global_strings__bindgen_ty_2__bindgen_ty_90, pub _py___iter__: _Py_global_strings__bindgen_ty_2__bindgen_ty_91, pub _py___itruediv__: _Py_global_strings__bindgen_ty_2__bindgen_ty_92, pub _py___ixor__: _Py_global_strings__bindgen_ty_2__bindgen_ty_93, pub _py___le__: _Py_global_strings__bindgen_ty_2__bindgen_ty_94, pub _py___len__: _Py_global_strings__bindgen_ty_2__bindgen_ty_95, pub _py___length_hint__: _Py_global_strings__bindgen_ty_2__bindgen_ty_96, pub _py___lltrace__: _Py_global_strings__bindgen_ty_2__bindgen_ty_97, pub _py___loader__: _Py_global_strings__bindgen_ty_2__bindgen_ty_98, pub _py___lshift__: _Py_global_strings__bindgen_ty_2__bindgen_ty_99, pub _py___lt__: _Py_global_strings__bindgen_ty_2__bindgen_ty_100, pub _py___main__: _Py_global_strings__bindgen_ty_2__bindgen_ty_101, pub _py___matmul__: _Py_global_strings__bindgen_ty_2__bindgen_ty_102, pub _py___missing__: _Py_global_strings__bindgen_ty_2__bindgen_ty_103, pub _py___mod__: _Py_global_strings__bindgen_ty_2__bindgen_ty_104, pub _py___module__: _Py_global_strings__bindgen_ty_2__bindgen_ty_105, pub _py___mro_entries__: _Py_global_strings__bindgen_ty_2__bindgen_ty_106, pub _py___mul__: _Py_global_strings__bindgen_ty_2__bindgen_ty_107, pub _py___name__: _Py_global_strings__bindgen_ty_2__bindgen_ty_108, pub _py___ne__: _Py_global_strings__bindgen_ty_2__bindgen_ty_109, pub _py___neg__: _Py_global_strings__bindgen_ty_2__bindgen_ty_110, pub _py___new__: _Py_global_strings__bindgen_ty_2__bindgen_ty_111, pub _py___newobj__: _Py_global_strings__bindgen_ty_2__bindgen_ty_112, pub _py___newobj_ex__: _Py_global_strings__bindgen_ty_2__bindgen_ty_113, pub _py___next__: _Py_global_strings__bindgen_ty_2__bindgen_ty_114, pub _py___notes__: _Py_global_strings__bindgen_ty_2__bindgen_ty_115, pub _py___or__: _Py_global_strings__bindgen_ty_2__bindgen_ty_116, pub _py___orig_class__: _Py_global_strings__bindgen_ty_2__bindgen_ty_117, pub _py___origin__: _Py_global_strings__bindgen_ty_2__bindgen_ty_118, pub _py___package__: _Py_global_strings__bindgen_ty_2__bindgen_ty_119, pub _py___parameters__: _Py_global_strings__bindgen_ty_2__bindgen_ty_120, pub _py___path__: _Py_global_strings__bindgen_ty_2__bindgen_ty_121, pub _py___pos__: _Py_global_strings__bindgen_ty_2__bindgen_ty_122, pub _py___pow__: _Py_global_strings__bindgen_ty_2__bindgen_ty_123, pub _py___prepare__: _Py_global_strings__bindgen_ty_2__bindgen_ty_124, pub _py___qualname__: _Py_global_strings__bindgen_ty_2__bindgen_ty_125, pub _py___radd__: _Py_global_strings__bindgen_ty_2__bindgen_ty_126, pub _py___rand__: _Py_global_strings__bindgen_ty_2__bindgen_ty_127, pub _py___rdivmod__: _Py_global_strings__bindgen_ty_2__bindgen_ty_128, pub _py___reduce__: _Py_global_strings__bindgen_ty_2__bindgen_ty_129, pub _py___reduce_ex__: _Py_global_strings__bindgen_ty_2__bindgen_ty_130, pub _py___release_buffer__: _Py_global_strings__bindgen_ty_2__bindgen_ty_131, pub _py___repr__: _Py_global_strings__bindgen_ty_2__bindgen_ty_132, pub _py___reversed__: _Py_global_strings__bindgen_ty_2__bindgen_ty_133, pub _py___rfloordiv__: _Py_global_strings__bindgen_ty_2__bindgen_ty_134, pub _py___rlshift__: _Py_global_strings__bindgen_ty_2__bindgen_ty_135, pub _py___rmatmul__: _Py_global_strings__bindgen_ty_2__bindgen_ty_136, pub _py___rmod__: _Py_global_strings__bindgen_ty_2__bindgen_ty_137, pub _py___rmul__: _Py_global_strings__bindgen_ty_2__bindgen_ty_138, pub _py___ror__: _Py_global_strings__bindgen_ty_2__bindgen_ty_139, pub _py___round__: _Py_global_strings__bindgen_ty_2__bindgen_ty_140, pub _py___rpow__: _Py_global_strings__bindgen_ty_2__bindgen_ty_141, pub _py___rrshift__: _Py_global_strings__bindgen_ty_2__bindgen_ty_142, pub _py___rshift__: _Py_global_strings__bindgen_ty_2__bindgen_ty_143, pub _py___rsub__: _Py_global_strings__bindgen_ty_2__bindgen_ty_144, pub _py___rtruediv__: _Py_global_strings__bindgen_ty_2__bindgen_ty_145, pub _py___rxor__: _Py_global_strings__bindgen_ty_2__bindgen_ty_146, pub _py___set__: _Py_global_strings__bindgen_ty_2__bindgen_ty_147, pub _py___set_name__: _Py_global_strings__bindgen_ty_2__bindgen_ty_148, pub _py___setattr__: _Py_global_strings__bindgen_ty_2__bindgen_ty_149, pub _py___setitem__: _Py_global_strings__bindgen_ty_2__bindgen_ty_150, pub _py___setstate__: _Py_global_strings__bindgen_ty_2__bindgen_ty_151, pub _py___sizeof__: _Py_global_strings__bindgen_ty_2__bindgen_ty_152, pub _py___slotnames__: _Py_global_strings__bindgen_ty_2__bindgen_ty_153, pub _py___slots__: _Py_global_strings__bindgen_ty_2__bindgen_ty_154, pub _py___spec__: _Py_global_strings__bindgen_ty_2__bindgen_ty_155, pub _py___str__: _Py_global_strings__bindgen_ty_2__bindgen_ty_156, pub _py___sub__: _Py_global_strings__bindgen_ty_2__bindgen_ty_157, pub _py___subclasscheck__: _Py_global_strings__bindgen_ty_2__bindgen_ty_158, pub _py___subclasshook__: _Py_global_strings__bindgen_ty_2__bindgen_ty_159, pub _py___truediv__: _Py_global_strings__bindgen_ty_2__bindgen_ty_160, pub _py___trunc__: _Py_global_strings__bindgen_ty_2__bindgen_ty_161, pub _py___type_params__: _Py_global_strings__bindgen_ty_2__bindgen_ty_162, pub _py___typing_is_unpacked_typevartuple__: _Py_global_strings__bindgen_ty_2__bindgen_ty_163, pub _py___typing_prepare_subst__: _Py_global_strings__bindgen_ty_2__bindgen_ty_164, pub _py___typing_subst__: _Py_global_strings__bindgen_ty_2__bindgen_ty_165, pub _py___typing_unpacked_tuple_args__: _Py_global_strings__bindgen_ty_2__bindgen_ty_166, pub _py___warningregistry__: _Py_global_strings__bindgen_ty_2__bindgen_ty_167, pub _py___weaklistoffset__: _Py_global_strings__bindgen_ty_2__bindgen_ty_168, pub _py___weakref__: _Py_global_strings__bindgen_ty_2__bindgen_ty_169, pub _py___xor__: _Py_global_strings__bindgen_ty_2__bindgen_ty_170, pub _py__abc_impl: _Py_global_strings__bindgen_ty_2__bindgen_ty_171, pub _py__abstract_: _Py_global_strings__bindgen_ty_2__bindgen_ty_172, pub _py__active: _Py_global_strings__bindgen_ty_2__bindgen_ty_173, pub _py__annotation: _Py_global_strings__bindgen_ty_2__bindgen_ty_174, pub _py__anonymous_: _Py_global_strings__bindgen_ty_2__bindgen_ty_175, pub _py__argtypes_: _Py_global_strings__bindgen_ty_2__bindgen_ty_176, pub _py__as_parameter_: _Py_global_strings__bindgen_ty_2__bindgen_ty_177, pub _py__asyncio_future_blocking: _Py_global_strings__bindgen_ty_2__bindgen_ty_178, pub _py__blksize: _Py_global_strings__bindgen_ty_2__bindgen_ty_179, pub _py__bootstrap: _Py_global_strings__bindgen_ty_2__bindgen_ty_180, pub _py__check_retval_: _Py_global_strings__bindgen_ty_2__bindgen_ty_181, pub _py__dealloc_warn: _Py_global_strings__bindgen_ty_2__bindgen_ty_182, pub _py__feature_version: _Py_global_strings__bindgen_ty_2__bindgen_ty_183, pub _py__fields_: _Py_global_strings__bindgen_ty_2__bindgen_ty_184, pub _py__finalizing: _Py_global_strings__bindgen_ty_2__bindgen_ty_185, pub _py__find_and_load: _Py_global_strings__bindgen_ty_2__bindgen_ty_186, pub _py__fix_up_module: _Py_global_strings__bindgen_ty_2__bindgen_ty_187, pub _py__flags_: _Py_global_strings__bindgen_ty_2__bindgen_ty_188, pub _py__get_sourcefile: _Py_global_strings__bindgen_ty_2__bindgen_ty_189, pub _py__handle_fromlist: _Py_global_strings__bindgen_ty_2__bindgen_ty_190, pub _py__initializing: _Py_global_strings__bindgen_ty_2__bindgen_ty_191, pub _py__io: _Py_global_strings__bindgen_ty_2__bindgen_ty_192, pub _py__is_text_encoding: _Py_global_strings__bindgen_ty_2__bindgen_ty_193, pub _py__length_: _Py_global_strings__bindgen_ty_2__bindgen_ty_194, pub _py__limbo: _Py_global_strings__bindgen_ty_2__bindgen_ty_195, pub _py__lock_unlock_module: _Py_global_strings__bindgen_ty_2__bindgen_ty_196, pub _py__loop: _Py_global_strings__bindgen_ty_2__bindgen_ty_197, pub _py__needs_com_addref_: _Py_global_strings__bindgen_ty_2__bindgen_ty_198, pub _py__pack_: _Py_global_strings__bindgen_ty_2__bindgen_ty_199, pub _py__restype_: _Py_global_strings__bindgen_ty_2__bindgen_ty_200, pub _py__showwarnmsg: _Py_global_strings__bindgen_ty_2__bindgen_ty_201, pub _py__shutdown: _Py_global_strings__bindgen_ty_2__bindgen_ty_202, pub _py__slotnames: _Py_global_strings__bindgen_ty_2__bindgen_ty_203, pub _py__strptime_datetime: _Py_global_strings__bindgen_ty_2__bindgen_ty_204, pub _py__swappedbytes_: _Py_global_strings__bindgen_ty_2__bindgen_ty_205, pub _py__type_: _Py_global_strings__bindgen_ty_2__bindgen_ty_206, pub _py__uninitialized_submodules: _Py_global_strings__bindgen_ty_2__bindgen_ty_207, pub _py__warn_unawaited_coroutine: _Py_global_strings__bindgen_ty_2__bindgen_ty_208, pub _py__xoptions: _Py_global_strings__bindgen_ty_2__bindgen_ty_209, pub _py_a: _Py_global_strings__bindgen_ty_2__bindgen_ty_210, pub _py_abs_tol: _Py_global_strings__bindgen_ty_2__bindgen_ty_211, pub _py_access: _Py_global_strings__bindgen_ty_2__bindgen_ty_212, pub _py_add: _Py_global_strings__bindgen_ty_2__bindgen_ty_213, pub _py_add_done_callback: _Py_global_strings__bindgen_ty_2__bindgen_ty_214, pub _py_after_in_child: _Py_global_strings__bindgen_ty_2__bindgen_ty_215, pub _py_after_in_parent: _Py_global_strings__bindgen_ty_2__bindgen_ty_216, pub _py_aggregate_class: _Py_global_strings__bindgen_ty_2__bindgen_ty_217, pub _py_alias: _Py_global_strings__bindgen_ty_2__bindgen_ty_218, pub _py_append: _Py_global_strings__bindgen_ty_2__bindgen_ty_219, pub _py_arg: _Py_global_strings__bindgen_ty_2__bindgen_ty_220, pub _py_argdefs: _Py_global_strings__bindgen_ty_2__bindgen_ty_221, pub _py_args: _Py_global_strings__bindgen_ty_2__bindgen_ty_222, pub _py_arguments: _Py_global_strings__bindgen_ty_2__bindgen_ty_223, pub _py_argv: _Py_global_strings__bindgen_ty_2__bindgen_ty_224, pub _py_as_integer_ratio: _Py_global_strings__bindgen_ty_2__bindgen_ty_225, pub _py_ast: _Py_global_strings__bindgen_ty_2__bindgen_ty_226, pub _py_attribute: _Py_global_strings__bindgen_ty_2__bindgen_ty_227, pub _py_authorizer_callback: _Py_global_strings__bindgen_ty_2__bindgen_ty_228, pub _py_autocommit: _Py_global_strings__bindgen_ty_2__bindgen_ty_229, pub _py_b: _Py_global_strings__bindgen_ty_2__bindgen_ty_230, pub _py_backtick: _Py_global_strings__bindgen_ty_2__bindgen_ty_231, pub _py_base: _Py_global_strings__bindgen_ty_2__bindgen_ty_232, pub _py_before: _Py_global_strings__bindgen_ty_2__bindgen_ty_233, pub _py_big: _Py_global_strings__bindgen_ty_2__bindgen_ty_234, pub _py_binary_form: _Py_global_strings__bindgen_ty_2__bindgen_ty_235, pub _py_block: _Py_global_strings__bindgen_ty_2__bindgen_ty_236, pub _py_bound: _Py_global_strings__bindgen_ty_2__bindgen_ty_237, pub _py_buffer: _Py_global_strings__bindgen_ty_2__bindgen_ty_238, pub _py_buffer_callback: _Py_global_strings__bindgen_ty_2__bindgen_ty_239, pub _py_buffer_size: _Py_global_strings__bindgen_ty_2__bindgen_ty_240, pub _py_buffering: _Py_global_strings__bindgen_ty_2__bindgen_ty_241, pub _py_buffers: _Py_global_strings__bindgen_ty_2__bindgen_ty_242, pub _py_bufsize: _Py_global_strings__bindgen_ty_2__bindgen_ty_243, pub _py_builtins: _Py_global_strings__bindgen_ty_2__bindgen_ty_244, pub _py_byteorder: _Py_global_strings__bindgen_ty_2__bindgen_ty_245, pub _py_bytes: _Py_global_strings__bindgen_ty_2__bindgen_ty_246, pub _py_bytes_per_sep: _Py_global_strings__bindgen_ty_2__bindgen_ty_247, pub _py_c: _Py_global_strings__bindgen_ty_2__bindgen_ty_248, pub _py_c_call: _Py_global_strings__bindgen_ty_2__bindgen_ty_249, pub _py_c_exception: _Py_global_strings__bindgen_ty_2__bindgen_ty_250, pub _py_c_return: _Py_global_strings__bindgen_ty_2__bindgen_ty_251, pub _py_cached_statements: _Py_global_strings__bindgen_ty_2__bindgen_ty_252, pub _py_cadata: _Py_global_strings__bindgen_ty_2__bindgen_ty_253, pub _py_cafile: _Py_global_strings__bindgen_ty_2__bindgen_ty_254, pub _py_call: _Py_global_strings__bindgen_ty_2__bindgen_ty_255, pub _py_call_exception_handler: _Py_global_strings__bindgen_ty_2__bindgen_ty_256, pub _py_call_soon: _Py_global_strings__bindgen_ty_2__bindgen_ty_257, pub _py_cancel: _Py_global_strings__bindgen_ty_2__bindgen_ty_258, pub _py_capath: _Py_global_strings__bindgen_ty_2__bindgen_ty_259, pub _py_category: _Py_global_strings__bindgen_ty_2__bindgen_ty_260, pub _py_cb_type: _Py_global_strings__bindgen_ty_2__bindgen_ty_261, pub _py_certfile: _Py_global_strings__bindgen_ty_2__bindgen_ty_262, pub _py_check_same_thread: _Py_global_strings__bindgen_ty_2__bindgen_ty_263, pub _py_clear: _Py_global_strings__bindgen_ty_2__bindgen_ty_264, pub _py_close: _Py_global_strings__bindgen_ty_2__bindgen_ty_265, pub _py_closed: _Py_global_strings__bindgen_ty_2__bindgen_ty_266, pub _py_closefd: _Py_global_strings__bindgen_ty_2__bindgen_ty_267, pub _py_closure: _Py_global_strings__bindgen_ty_2__bindgen_ty_268, pub _py_co_argcount: _Py_global_strings__bindgen_ty_2__bindgen_ty_269, pub _py_co_cellvars: _Py_global_strings__bindgen_ty_2__bindgen_ty_270, pub _py_co_code: _Py_global_strings__bindgen_ty_2__bindgen_ty_271, pub _py_co_consts: _Py_global_strings__bindgen_ty_2__bindgen_ty_272, pub _py_co_exceptiontable: _Py_global_strings__bindgen_ty_2__bindgen_ty_273, pub _py_co_filename: _Py_global_strings__bindgen_ty_2__bindgen_ty_274, pub _py_co_firstlineno: _Py_global_strings__bindgen_ty_2__bindgen_ty_275, pub _py_co_flags: _Py_global_strings__bindgen_ty_2__bindgen_ty_276, pub _py_co_freevars: _Py_global_strings__bindgen_ty_2__bindgen_ty_277, pub _py_co_kwonlyargcount: _Py_global_strings__bindgen_ty_2__bindgen_ty_278, pub _py_co_linetable: _Py_global_strings__bindgen_ty_2__bindgen_ty_279, pub _py_co_name: _Py_global_strings__bindgen_ty_2__bindgen_ty_280, pub _py_co_names: _Py_global_strings__bindgen_ty_2__bindgen_ty_281, pub _py_co_nlocals: _Py_global_strings__bindgen_ty_2__bindgen_ty_282, pub _py_co_posonlyargcount: _Py_global_strings__bindgen_ty_2__bindgen_ty_283, pub _py_co_qualname: _Py_global_strings__bindgen_ty_2__bindgen_ty_284, pub _py_co_stacksize: _Py_global_strings__bindgen_ty_2__bindgen_ty_285, pub _py_co_varnames: _Py_global_strings__bindgen_ty_2__bindgen_ty_286, pub _py_code: _Py_global_strings__bindgen_ty_2__bindgen_ty_287, pub _py_command: _Py_global_strings__bindgen_ty_2__bindgen_ty_288, pub _py_comment_factory: _Py_global_strings__bindgen_ty_2__bindgen_ty_289, pub _py_compile_mode: _Py_global_strings__bindgen_ty_2__bindgen_ty_290, pub _py_consts: _Py_global_strings__bindgen_ty_2__bindgen_ty_291, pub _py_context: _Py_global_strings__bindgen_ty_2__bindgen_ty_292, pub _py_contravariant: _Py_global_strings__bindgen_ty_2__bindgen_ty_293, pub _py_cookie: _Py_global_strings__bindgen_ty_2__bindgen_ty_294, pub _py_copy: _Py_global_strings__bindgen_ty_2__bindgen_ty_295, pub _py_copyreg: _Py_global_strings__bindgen_ty_2__bindgen_ty_296, pub _py_coro: _Py_global_strings__bindgen_ty_2__bindgen_ty_297, pub _py_count: _Py_global_strings__bindgen_ty_2__bindgen_ty_298, pub _py_covariant: _Py_global_strings__bindgen_ty_2__bindgen_ty_299, pub _py_cwd: _Py_global_strings__bindgen_ty_2__bindgen_ty_300, pub _py_d: _Py_global_strings__bindgen_ty_2__bindgen_ty_301, pub _py_data: _Py_global_strings__bindgen_ty_2__bindgen_ty_302, pub _py_database: _Py_global_strings__bindgen_ty_2__bindgen_ty_303, pub _py_decode: _Py_global_strings__bindgen_ty_2__bindgen_ty_304, pub _py_decoder: _Py_global_strings__bindgen_ty_2__bindgen_ty_305, pub _py_default: _Py_global_strings__bindgen_ty_2__bindgen_ty_306, pub _py_defaultaction: _Py_global_strings__bindgen_ty_2__bindgen_ty_307, pub _py_delete: _Py_global_strings__bindgen_ty_2__bindgen_ty_308, pub _py_depth: _Py_global_strings__bindgen_ty_2__bindgen_ty_309, pub _py_detect_types: _Py_global_strings__bindgen_ty_2__bindgen_ty_310, pub _py_deterministic: _Py_global_strings__bindgen_ty_2__bindgen_ty_311, pub _py_device: _Py_global_strings__bindgen_ty_2__bindgen_ty_312, pub _py_dict: _Py_global_strings__bindgen_ty_2__bindgen_ty_313, pub _py_dictcomp: _Py_global_strings__bindgen_ty_2__bindgen_ty_314, pub _py_difference_update: _Py_global_strings__bindgen_ty_2__bindgen_ty_315, pub _py_digest: _Py_global_strings__bindgen_ty_2__bindgen_ty_316, pub _py_digest_size: _Py_global_strings__bindgen_ty_2__bindgen_ty_317, pub _py_digestmod: _Py_global_strings__bindgen_ty_2__bindgen_ty_318, pub _py_dir_fd: _Py_global_strings__bindgen_ty_2__bindgen_ty_319, pub _py_discard: _Py_global_strings__bindgen_ty_2__bindgen_ty_320, pub _py_dispatch_table: _Py_global_strings__bindgen_ty_2__bindgen_ty_321, pub _py_displayhook: _Py_global_strings__bindgen_ty_2__bindgen_ty_322, pub _py_dklen: _Py_global_strings__bindgen_ty_2__bindgen_ty_323, pub _py_doc: _Py_global_strings__bindgen_ty_2__bindgen_ty_324, pub _py_dont_inherit: _Py_global_strings__bindgen_ty_2__bindgen_ty_325, pub _py_dst: _Py_global_strings__bindgen_ty_2__bindgen_ty_326, pub _py_dst_dir_fd: _Py_global_strings__bindgen_ty_2__bindgen_ty_327, pub _py_duration: _Py_global_strings__bindgen_ty_2__bindgen_ty_328, pub _py_e: _Py_global_strings__bindgen_ty_2__bindgen_ty_329, pub _py_eager_start: _Py_global_strings__bindgen_ty_2__bindgen_ty_330, pub _py_effective_ids: _Py_global_strings__bindgen_ty_2__bindgen_ty_331, pub _py_element_factory: _Py_global_strings__bindgen_ty_2__bindgen_ty_332, pub _py_encode: _Py_global_strings__bindgen_ty_2__bindgen_ty_333, pub _py_encoding: _Py_global_strings__bindgen_ty_2__bindgen_ty_334, pub _py_end: _Py_global_strings__bindgen_ty_2__bindgen_ty_335, pub _py_end_lineno: _Py_global_strings__bindgen_ty_2__bindgen_ty_336, pub _py_end_offset: _Py_global_strings__bindgen_ty_2__bindgen_ty_337, pub _py_endpos: _Py_global_strings__bindgen_ty_2__bindgen_ty_338, pub _py_entrypoint: _Py_global_strings__bindgen_ty_2__bindgen_ty_339, pub _py_env: _Py_global_strings__bindgen_ty_2__bindgen_ty_340, pub _py_errors: _Py_global_strings__bindgen_ty_2__bindgen_ty_341, pub _py_event: _Py_global_strings__bindgen_ty_2__bindgen_ty_342, pub _py_eventmask: _Py_global_strings__bindgen_ty_2__bindgen_ty_343, pub _py_exc_type: _Py_global_strings__bindgen_ty_2__bindgen_ty_344, pub _py_exc_value: _Py_global_strings__bindgen_ty_2__bindgen_ty_345, pub _py_excepthook: _Py_global_strings__bindgen_ty_2__bindgen_ty_346, pub _py_exception: _Py_global_strings__bindgen_ty_2__bindgen_ty_347, pub _py_existing_file_name: _Py_global_strings__bindgen_ty_2__bindgen_ty_348, pub _py_exp: _Py_global_strings__bindgen_ty_2__bindgen_ty_349, pub _py_extend: _Py_global_strings__bindgen_ty_2__bindgen_ty_350, pub _py_extra_tokens: _Py_global_strings__bindgen_ty_2__bindgen_ty_351, pub _py_facility: _Py_global_strings__bindgen_ty_2__bindgen_ty_352, pub _py_factory: _Py_global_strings__bindgen_ty_2__bindgen_ty_353, pub _py_false: _Py_global_strings__bindgen_ty_2__bindgen_ty_354, pub _py_family: _Py_global_strings__bindgen_ty_2__bindgen_ty_355, pub _py_fanout: _Py_global_strings__bindgen_ty_2__bindgen_ty_356, pub _py_fd: _Py_global_strings__bindgen_ty_2__bindgen_ty_357, pub _py_fd2: _Py_global_strings__bindgen_ty_2__bindgen_ty_358, pub _py_fdel: _Py_global_strings__bindgen_ty_2__bindgen_ty_359, pub _py_fget: _Py_global_strings__bindgen_ty_2__bindgen_ty_360, pub _py_file: _Py_global_strings__bindgen_ty_2__bindgen_ty_361, pub _py_file_actions: _Py_global_strings__bindgen_ty_2__bindgen_ty_362, pub _py_filename: _Py_global_strings__bindgen_ty_2__bindgen_ty_363, pub _py_fileno: _Py_global_strings__bindgen_ty_2__bindgen_ty_364, pub _py_filepath: _Py_global_strings__bindgen_ty_2__bindgen_ty_365, pub _py_fillvalue: _Py_global_strings__bindgen_ty_2__bindgen_ty_366, pub _py_filters: _Py_global_strings__bindgen_ty_2__bindgen_ty_367, pub _py_final: _Py_global_strings__bindgen_ty_2__bindgen_ty_368, pub _py_find_class: _Py_global_strings__bindgen_ty_2__bindgen_ty_369, pub _py_fix_imports: _Py_global_strings__bindgen_ty_2__bindgen_ty_370, pub _py_flags: _Py_global_strings__bindgen_ty_2__bindgen_ty_371, pub _py_flush: _Py_global_strings__bindgen_ty_2__bindgen_ty_372, pub _py_follow_symlinks: _Py_global_strings__bindgen_ty_2__bindgen_ty_373, pub _py_format: _Py_global_strings__bindgen_ty_2__bindgen_ty_374, pub _py_frequency: _Py_global_strings__bindgen_ty_2__bindgen_ty_375, pub _py_from_param: _Py_global_strings__bindgen_ty_2__bindgen_ty_376, pub _py_fromlist: _Py_global_strings__bindgen_ty_2__bindgen_ty_377, pub _py_fromtimestamp: _Py_global_strings__bindgen_ty_2__bindgen_ty_378, pub _py_fromutc: _Py_global_strings__bindgen_ty_2__bindgen_ty_379, pub _py_fset: _Py_global_strings__bindgen_ty_2__bindgen_ty_380, pub _py_func: _Py_global_strings__bindgen_ty_2__bindgen_ty_381, pub _py_future: _Py_global_strings__bindgen_ty_2__bindgen_ty_382, pub _py_generation: _Py_global_strings__bindgen_ty_2__bindgen_ty_383, pub _py_genexpr: _Py_global_strings__bindgen_ty_2__bindgen_ty_384, pub _py_get: _Py_global_strings__bindgen_ty_2__bindgen_ty_385, pub _py_get_debug: _Py_global_strings__bindgen_ty_2__bindgen_ty_386, pub _py_get_event_loop: _Py_global_strings__bindgen_ty_2__bindgen_ty_387, pub _py_get_loop: _Py_global_strings__bindgen_ty_2__bindgen_ty_388, pub _py_get_source: _Py_global_strings__bindgen_ty_2__bindgen_ty_389, pub _py_getattr: _Py_global_strings__bindgen_ty_2__bindgen_ty_390, pub _py_getstate: _Py_global_strings__bindgen_ty_2__bindgen_ty_391, pub _py_gid: _Py_global_strings__bindgen_ty_2__bindgen_ty_392, pub _py_globals: _Py_global_strings__bindgen_ty_2__bindgen_ty_393, pub _py_groupindex: _Py_global_strings__bindgen_ty_2__bindgen_ty_394, pub _py_groups: _Py_global_strings__bindgen_ty_2__bindgen_ty_395, pub _py_handle: _Py_global_strings__bindgen_ty_2__bindgen_ty_396, pub _py_hash_name: _Py_global_strings__bindgen_ty_2__bindgen_ty_397, pub _py_header: _Py_global_strings__bindgen_ty_2__bindgen_ty_398, pub _py_headers: _Py_global_strings__bindgen_ty_2__bindgen_ty_399, pub _py_hi: _Py_global_strings__bindgen_ty_2__bindgen_ty_400, pub _py_hook: _Py_global_strings__bindgen_ty_2__bindgen_ty_401, pub _py_id: _Py_global_strings__bindgen_ty_2__bindgen_ty_402, pub _py_ident: _Py_global_strings__bindgen_ty_2__bindgen_ty_403, pub _py_ignore: _Py_global_strings__bindgen_ty_2__bindgen_ty_404, pub _py_imag: _Py_global_strings__bindgen_ty_2__bindgen_ty_405, pub _py_importlib: _Py_global_strings__bindgen_ty_2__bindgen_ty_406, pub _py_in_fd: _Py_global_strings__bindgen_ty_2__bindgen_ty_407, pub _py_incoming: _Py_global_strings__bindgen_ty_2__bindgen_ty_408, pub _py_indexgroup: _Py_global_strings__bindgen_ty_2__bindgen_ty_409, pub _py_inf: _Py_global_strings__bindgen_ty_2__bindgen_ty_410, pub _py_infer_variance: _Py_global_strings__bindgen_ty_2__bindgen_ty_411, pub _py_inheritable: _Py_global_strings__bindgen_ty_2__bindgen_ty_412, pub _py_initial: _Py_global_strings__bindgen_ty_2__bindgen_ty_413, pub _py_initial_bytes: _Py_global_strings__bindgen_ty_2__bindgen_ty_414, pub _py_initial_value: _Py_global_strings__bindgen_ty_2__bindgen_ty_415, pub _py_initval: _Py_global_strings__bindgen_ty_2__bindgen_ty_416, pub _py_inner_size: _Py_global_strings__bindgen_ty_2__bindgen_ty_417, pub _py_input: _Py_global_strings__bindgen_ty_2__bindgen_ty_418, pub _py_insert_comments: _Py_global_strings__bindgen_ty_2__bindgen_ty_419, pub _py_insert_pis: _Py_global_strings__bindgen_ty_2__bindgen_ty_420, pub _py_instructions: _Py_global_strings__bindgen_ty_2__bindgen_ty_421, pub _py_intern: _Py_global_strings__bindgen_ty_2__bindgen_ty_422, pub _py_intersection: _Py_global_strings__bindgen_ty_2__bindgen_ty_423, pub _py_is_running: _Py_global_strings__bindgen_ty_2__bindgen_ty_424, pub _py_isatty: _Py_global_strings__bindgen_ty_2__bindgen_ty_425, pub _py_isinstance: _Py_global_strings__bindgen_ty_2__bindgen_ty_426, pub _py_isoformat: _Py_global_strings__bindgen_ty_2__bindgen_ty_427, pub _py_isolation_level: _Py_global_strings__bindgen_ty_2__bindgen_ty_428, pub _py_istext: _Py_global_strings__bindgen_ty_2__bindgen_ty_429, pub _py_item: _Py_global_strings__bindgen_ty_2__bindgen_ty_430, pub _py_items: _Py_global_strings__bindgen_ty_2__bindgen_ty_431, pub _py_iter: _Py_global_strings__bindgen_ty_2__bindgen_ty_432, pub _py_iterable: _Py_global_strings__bindgen_ty_2__bindgen_ty_433, pub _py_iterations: _Py_global_strings__bindgen_ty_2__bindgen_ty_434, pub _py_join: _Py_global_strings__bindgen_ty_2__bindgen_ty_435, pub _py_jump: _Py_global_strings__bindgen_ty_2__bindgen_ty_436, pub _py_keepends: _Py_global_strings__bindgen_ty_2__bindgen_ty_437, pub _py_key: _Py_global_strings__bindgen_ty_2__bindgen_ty_438, pub _py_keyfile: _Py_global_strings__bindgen_ty_2__bindgen_ty_439, pub _py_keys: _Py_global_strings__bindgen_ty_2__bindgen_ty_440, pub _py_kind: _Py_global_strings__bindgen_ty_2__bindgen_ty_441, pub _py_kw: _Py_global_strings__bindgen_ty_2__bindgen_ty_442, pub _py_kw1: _Py_global_strings__bindgen_ty_2__bindgen_ty_443, pub _py_kw2: _Py_global_strings__bindgen_ty_2__bindgen_ty_444, pub _py_lambda: _Py_global_strings__bindgen_ty_2__bindgen_ty_445, pub _py_last: _Py_global_strings__bindgen_ty_2__bindgen_ty_446, pub _py_last_exc: _Py_global_strings__bindgen_ty_2__bindgen_ty_447, pub _py_last_node: _Py_global_strings__bindgen_ty_2__bindgen_ty_448, pub _py_last_traceback: _Py_global_strings__bindgen_ty_2__bindgen_ty_449, pub _py_last_type: _Py_global_strings__bindgen_ty_2__bindgen_ty_450, pub _py_last_value: _Py_global_strings__bindgen_ty_2__bindgen_ty_451, pub _py_latin1: _Py_global_strings__bindgen_ty_2__bindgen_ty_452, pub _py_leaf_size: _Py_global_strings__bindgen_ty_2__bindgen_ty_453, pub _py_len: _Py_global_strings__bindgen_ty_2__bindgen_ty_454, pub _py_length: _Py_global_strings__bindgen_ty_2__bindgen_ty_455, pub _py_level: _Py_global_strings__bindgen_ty_2__bindgen_ty_456, pub _py_limit: _Py_global_strings__bindgen_ty_2__bindgen_ty_457, pub _py_line: _Py_global_strings__bindgen_ty_2__bindgen_ty_458, pub _py_line_buffering: _Py_global_strings__bindgen_ty_2__bindgen_ty_459, pub _py_lineno: _Py_global_strings__bindgen_ty_2__bindgen_ty_460, pub _py_listcomp: _Py_global_strings__bindgen_ty_2__bindgen_ty_461, pub _py_little: _Py_global_strings__bindgen_ty_2__bindgen_ty_462, pub _py_lo: _Py_global_strings__bindgen_ty_2__bindgen_ty_463, pub _py_locale: _Py_global_strings__bindgen_ty_2__bindgen_ty_464, pub _py_locals: _Py_global_strings__bindgen_ty_2__bindgen_ty_465, pub _py_logoption: _Py_global_strings__bindgen_ty_2__bindgen_ty_466, pub _py_loop: _Py_global_strings__bindgen_ty_2__bindgen_ty_467, pub _py_mapping: _Py_global_strings__bindgen_ty_2__bindgen_ty_468, pub _py_match: _Py_global_strings__bindgen_ty_2__bindgen_ty_469, pub _py_max_length: _Py_global_strings__bindgen_ty_2__bindgen_ty_470, pub _py_maxdigits: _Py_global_strings__bindgen_ty_2__bindgen_ty_471, pub _py_maxevents: _Py_global_strings__bindgen_ty_2__bindgen_ty_472, pub _py_maxmem: _Py_global_strings__bindgen_ty_2__bindgen_ty_473, pub _py_maxsplit: _Py_global_strings__bindgen_ty_2__bindgen_ty_474, pub _py_maxvalue: _Py_global_strings__bindgen_ty_2__bindgen_ty_475, pub _py_memLevel: _Py_global_strings__bindgen_ty_2__bindgen_ty_476, pub _py_memlimit: _Py_global_strings__bindgen_ty_2__bindgen_ty_477, pub _py_message: _Py_global_strings__bindgen_ty_2__bindgen_ty_478, pub _py_metaclass: _Py_global_strings__bindgen_ty_2__bindgen_ty_479, pub _py_metadata: _Py_global_strings__bindgen_ty_2__bindgen_ty_480, pub _py_method: _Py_global_strings__bindgen_ty_2__bindgen_ty_481, pub _py_mod: _Py_global_strings__bindgen_ty_2__bindgen_ty_482, pub _py_mode: _Py_global_strings__bindgen_ty_2__bindgen_ty_483, pub _py_module: _Py_global_strings__bindgen_ty_2__bindgen_ty_484, pub _py_module_globals: _Py_global_strings__bindgen_ty_2__bindgen_ty_485, pub _py_modules: _Py_global_strings__bindgen_ty_2__bindgen_ty_486, pub _py_mro: _Py_global_strings__bindgen_ty_2__bindgen_ty_487, pub _py_msg: _Py_global_strings__bindgen_ty_2__bindgen_ty_488, pub _py_mycmp: _Py_global_strings__bindgen_ty_2__bindgen_ty_489, pub _py_n: _Py_global_strings__bindgen_ty_2__bindgen_ty_490, pub _py_n_arg: _Py_global_strings__bindgen_ty_2__bindgen_ty_491, pub _py_n_fields: _Py_global_strings__bindgen_ty_2__bindgen_ty_492, pub _py_n_sequence_fields: _Py_global_strings__bindgen_ty_2__bindgen_ty_493, pub _py_n_unnamed_fields: _Py_global_strings__bindgen_ty_2__bindgen_ty_494, pub _py_name: _Py_global_strings__bindgen_ty_2__bindgen_ty_495, pub _py_name_from: _Py_global_strings__bindgen_ty_2__bindgen_ty_496, pub _py_namespace_separator: _Py_global_strings__bindgen_ty_2__bindgen_ty_497, pub _py_namespaces: _Py_global_strings__bindgen_ty_2__bindgen_ty_498, pub _py_narg: _Py_global_strings__bindgen_ty_2__bindgen_ty_499, pub _py_ndigits: _Py_global_strings__bindgen_ty_2__bindgen_ty_500, pub _py_new_file_name: _Py_global_strings__bindgen_ty_2__bindgen_ty_501, pub _py_new_limit: _Py_global_strings__bindgen_ty_2__bindgen_ty_502, pub _py_newline: _Py_global_strings__bindgen_ty_2__bindgen_ty_503, pub _py_newlines: _Py_global_strings__bindgen_ty_2__bindgen_ty_504, pub _py_next: _Py_global_strings__bindgen_ty_2__bindgen_ty_505, pub _py_nlocals: _Py_global_strings__bindgen_ty_2__bindgen_ty_506, pub _py_node_depth: _Py_global_strings__bindgen_ty_2__bindgen_ty_507, pub _py_node_offset: _Py_global_strings__bindgen_ty_2__bindgen_ty_508, pub _py_ns: _Py_global_strings__bindgen_ty_2__bindgen_ty_509, pub _py_nstype: _Py_global_strings__bindgen_ty_2__bindgen_ty_510, pub _py_nt: _Py_global_strings__bindgen_ty_2__bindgen_ty_511, pub _py_null: _Py_global_strings__bindgen_ty_2__bindgen_ty_512, pub _py_number: _Py_global_strings__bindgen_ty_2__bindgen_ty_513, pub _py_obj: _Py_global_strings__bindgen_ty_2__bindgen_ty_514, pub _py_object: _Py_global_strings__bindgen_ty_2__bindgen_ty_515, pub _py_offset: _Py_global_strings__bindgen_ty_2__bindgen_ty_516, pub _py_offset_dst: _Py_global_strings__bindgen_ty_2__bindgen_ty_517, pub _py_offset_src: _Py_global_strings__bindgen_ty_2__bindgen_ty_518, pub _py_on_type_read: _Py_global_strings__bindgen_ty_2__bindgen_ty_519, pub _py_onceregistry: _Py_global_strings__bindgen_ty_2__bindgen_ty_520, pub _py_only_keys: _Py_global_strings__bindgen_ty_2__bindgen_ty_521, pub _py_oparg: _Py_global_strings__bindgen_ty_2__bindgen_ty_522, pub _py_opcode: _Py_global_strings__bindgen_ty_2__bindgen_ty_523, pub _py_open: _Py_global_strings__bindgen_ty_2__bindgen_ty_524, pub _py_opener: _Py_global_strings__bindgen_ty_2__bindgen_ty_525, pub _py_operation: _Py_global_strings__bindgen_ty_2__bindgen_ty_526, pub _py_optimize: _Py_global_strings__bindgen_ty_2__bindgen_ty_527, pub _py_options: _Py_global_strings__bindgen_ty_2__bindgen_ty_528, pub _py_order: _Py_global_strings__bindgen_ty_2__bindgen_ty_529, pub _py_origin: _Py_global_strings__bindgen_ty_2__bindgen_ty_530, pub _py_out_fd: _Py_global_strings__bindgen_ty_2__bindgen_ty_531, pub _py_outgoing: _Py_global_strings__bindgen_ty_2__bindgen_ty_532, pub _py_overlapped: _Py_global_strings__bindgen_ty_2__bindgen_ty_533, pub _py_owner: _Py_global_strings__bindgen_ty_2__bindgen_ty_534, pub _py_p: _Py_global_strings__bindgen_ty_2__bindgen_ty_535, pub _py_pages: _Py_global_strings__bindgen_ty_2__bindgen_ty_536, pub _py_parent: _Py_global_strings__bindgen_ty_2__bindgen_ty_537, pub _py_password: _Py_global_strings__bindgen_ty_2__bindgen_ty_538, pub _py_path: _Py_global_strings__bindgen_ty_2__bindgen_ty_539, pub _py_pattern: _Py_global_strings__bindgen_ty_2__bindgen_ty_540, pub _py_peek: _Py_global_strings__bindgen_ty_2__bindgen_ty_541, pub _py_persistent_id: _Py_global_strings__bindgen_ty_2__bindgen_ty_542, pub _py_persistent_load: _Py_global_strings__bindgen_ty_2__bindgen_ty_543, pub _py_person: _Py_global_strings__bindgen_ty_2__bindgen_ty_544, pub _py_pi_factory: _Py_global_strings__bindgen_ty_2__bindgen_ty_545, pub _py_pid: _Py_global_strings__bindgen_ty_2__bindgen_ty_546, pub _py_policy: _Py_global_strings__bindgen_ty_2__bindgen_ty_547, pub _py_pos: _Py_global_strings__bindgen_ty_2__bindgen_ty_548, pub _py_pos1: _Py_global_strings__bindgen_ty_2__bindgen_ty_549, pub _py_pos2: _Py_global_strings__bindgen_ty_2__bindgen_ty_550, pub _py_posix: _Py_global_strings__bindgen_ty_2__bindgen_ty_551, pub _py_print_file_and_line: _Py_global_strings__bindgen_ty_2__bindgen_ty_552, pub _py_priority: _Py_global_strings__bindgen_ty_2__bindgen_ty_553, pub _py_progress: _Py_global_strings__bindgen_ty_2__bindgen_ty_554, pub _py_progress_handler: _Py_global_strings__bindgen_ty_2__bindgen_ty_555, pub _py_progress_routine: _Py_global_strings__bindgen_ty_2__bindgen_ty_556, pub _py_proto: _Py_global_strings__bindgen_ty_2__bindgen_ty_557, pub _py_protocol: _Py_global_strings__bindgen_ty_2__bindgen_ty_558, pub _py_ps1: _Py_global_strings__bindgen_ty_2__bindgen_ty_559, pub _py_ps2: _Py_global_strings__bindgen_ty_2__bindgen_ty_560, pub _py_query: _Py_global_strings__bindgen_ty_2__bindgen_ty_561, pub _py_quotetabs: _Py_global_strings__bindgen_ty_2__bindgen_ty_562, pub _py_r: _Py_global_strings__bindgen_ty_2__bindgen_ty_563, pub _py_raw: _Py_global_strings__bindgen_ty_2__bindgen_ty_564, pub _py_read: _Py_global_strings__bindgen_ty_2__bindgen_ty_565, pub _py_read1: _Py_global_strings__bindgen_ty_2__bindgen_ty_566, pub _py_readable: _Py_global_strings__bindgen_ty_2__bindgen_ty_567, pub _py_readall: _Py_global_strings__bindgen_ty_2__bindgen_ty_568, pub _py_readinto: _Py_global_strings__bindgen_ty_2__bindgen_ty_569, pub _py_readinto1: _Py_global_strings__bindgen_ty_2__bindgen_ty_570, pub _py_readline: _Py_global_strings__bindgen_ty_2__bindgen_ty_571, pub _py_readonly: _Py_global_strings__bindgen_ty_2__bindgen_ty_572, pub _py_real: _Py_global_strings__bindgen_ty_2__bindgen_ty_573, pub _py_reducer_override: _Py_global_strings__bindgen_ty_2__bindgen_ty_574, pub _py_registry: _Py_global_strings__bindgen_ty_2__bindgen_ty_575, pub _py_rel_tol: _Py_global_strings__bindgen_ty_2__bindgen_ty_576, pub _py_release: _Py_global_strings__bindgen_ty_2__bindgen_ty_577, pub _py_reload: _Py_global_strings__bindgen_ty_2__bindgen_ty_578, pub _py_repl: _Py_global_strings__bindgen_ty_2__bindgen_ty_579, pub _py_replace: _Py_global_strings__bindgen_ty_2__bindgen_ty_580, pub _py_reserved: _Py_global_strings__bindgen_ty_2__bindgen_ty_581, pub _py_reset: _Py_global_strings__bindgen_ty_2__bindgen_ty_582, pub _py_resetids: _Py_global_strings__bindgen_ty_2__bindgen_ty_583, pub _py_return: _Py_global_strings__bindgen_ty_2__bindgen_ty_584, pub _py_reverse: _Py_global_strings__bindgen_ty_2__bindgen_ty_585, pub _py_reversed: _Py_global_strings__bindgen_ty_2__bindgen_ty_586, pub _py_s: _Py_global_strings__bindgen_ty_2__bindgen_ty_587, pub _py_salt: _Py_global_strings__bindgen_ty_2__bindgen_ty_588, pub _py_sched_priority: _Py_global_strings__bindgen_ty_2__bindgen_ty_589, pub _py_scheduler: _Py_global_strings__bindgen_ty_2__bindgen_ty_590, pub _py_seek: _Py_global_strings__bindgen_ty_2__bindgen_ty_591, pub _py_seekable: _Py_global_strings__bindgen_ty_2__bindgen_ty_592, pub _py_selectors: _Py_global_strings__bindgen_ty_2__bindgen_ty_593, pub _py_self: _Py_global_strings__bindgen_ty_2__bindgen_ty_594, pub _py_send: _Py_global_strings__bindgen_ty_2__bindgen_ty_595, pub _py_sep: _Py_global_strings__bindgen_ty_2__bindgen_ty_596, pub _py_sequence: _Py_global_strings__bindgen_ty_2__bindgen_ty_597, pub _py_server_hostname: _Py_global_strings__bindgen_ty_2__bindgen_ty_598, pub _py_server_side: _Py_global_strings__bindgen_ty_2__bindgen_ty_599, pub _py_session: _Py_global_strings__bindgen_ty_2__bindgen_ty_600, pub _py_setcomp: _Py_global_strings__bindgen_ty_2__bindgen_ty_601, pub _py_setpgroup: _Py_global_strings__bindgen_ty_2__bindgen_ty_602, pub _py_setsid: _Py_global_strings__bindgen_ty_2__bindgen_ty_603, pub _py_setsigdef: _Py_global_strings__bindgen_ty_2__bindgen_ty_604, pub _py_setsigmask: _Py_global_strings__bindgen_ty_2__bindgen_ty_605, pub _py_setstate: _Py_global_strings__bindgen_ty_2__bindgen_ty_606, pub _py_shape: _Py_global_strings__bindgen_ty_2__bindgen_ty_607, pub _py_show_cmd: _Py_global_strings__bindgen_ty_2__bindgen_ty_608, pub _py_signed: _Py_global_strings__bindgen_ty_2__bindgen_ty_609, pub _py_size: _Py_global_strings__bindgen_ty_2__bindgen_ty_610, pub _py_sizehint: _Py_global_strings__bindgen_ty_2__bindgen_ty_611, pub _py_skip_file_prefixes: _Py_global_strings__bindgen_ty_2__bindgen_ty_612, pub _py_sleep: _Py_global_strings__bindgen_ty_2__bindgen_ty_613, pub _py_sock: _Py_global_strings__bindgen_ty_2__bindgen_ty_614, pub _py_sort: _Py_global_strings__bindgen_ty_2__bindgen_ty_615, pub _py_sound: _Py_global_strings__bindgen_ty_2__bindgen_ty_616, pub _py_source: _Py_global_strings__bindgen_ty_2__bindgen_ty_617, pub _py_source_traceback: _Py_global_strings__bindgen_ty_2__bindgen_ty_618, pub _py_src: _Py_global_strings__bindgen_ty_2__bindgen_ty_619, pub _py_src_dir_fd: _Py_global_strings__bindgen_ty_2__bindgen_ty_620, pub _py_stacklevel: _Py_global_strings__bindgen_ty_2__bindgen_ty_621, pub _py_start: _Py_global_strings__bindgen_ty_2__bindgen_ty_622, pub _py_statement: _Py_global_strings__bindgen_ty_2__bindgen_ty_623, pub _py_status: _Py_global_strings__bindgen_ty_2__bindgen_ty_624, pub _py_stderr: _Py_global_strings__bindgen_ty_2__bindgen_ty_625, pub _py_stdin: _Py_global_strings__bindgen_ty_2__bindgen_ty_626, pub _py_stdout: _Py_global_strings__bindgen_ty_2__bindgen_ty_627, pub _py_step: _Py_global_strings__bindgen_ty_2__bindgen_ty_628, pub _py_steps: _Py_global_strings__bindgen_ty_2__bindgen_ty_629, pub _py_store_name: _Py_global_strings__bindgen_ty_2__bindgen_ty_630, pub _py_strategy: _Py_global_strings__bindgen_ty_2__bindgen_ty_631, pub _py_strftime: _Py_global_strings__bindgen_ty_2__bindgen_ty_632, pub _py_strict: _Py_global_strings__bindgen_ty_2__bindgen_ty_633, pub _py_strict_mode: _Py_global_strings__bindgen_ty_2__bindgen_ty_634, pub _py_string: _Py_global_strings__bindgen_ty_2__bindgen_ty_635, pub _py_sub_key: _Py_global_strings__bindgen_ty_2__bindgen_ty_636, pub _py_symmetric_difference_update: _Py_global_strings__bindgen_ty_2__bindgen_ty_637, pub _py_tabsize: _Py_global_strings__bindgen_ty_2__bindgen_ty_638, pub _py_tag: _Py_global_strings__bindgen_ty_2__bindgen_ty_639, pub _py_target: _Py_global_strings__bindgen_ty_2__bindgen_ty_640, pub _py_target_is_directory: _Py_global_strings__bindgen_ty_2__bindgen_ty_641, pub _py_task: _Py_global_strings__bindgen_ty_2__bindgen_ty_642, pub _py_tb_frame: _Py_global_strings__bindgen_ty_2__bindgen_ty_643, pub _py_tb_lasti: _Py_global_strings__bindgen_ty_2__bindgen_ty_644, pub _py_tb_lineno: _Py_global_strings__bindgen_ty_2__bindgen_ty_645, pub _py_tb_next: _Py_global_strings__bindgen_ty_2__bindgen_ty_646, pub _py_tell: _Py_global_strings__bindgen_ty_2__bindgen_ty_647, pub _py_template: _Py_global_strings__bindgen_ty_2__bindgen_ty_648, pub _py_term: _Py_global_strings__bindgen_ty_2__bindgen_ty_649, pub _py_text: _Py_global_strings__bindgen_ty_2__bindgen_ty_650, pub _py_threading: _Py_global_strings__bindgen_ty_2__bindgen_ty_651, pub _py_throw: _Py_global_strings__bindgen_ty_2__bindgen_ty_652, pub _py_timeout: _Py_global_strings__bindgen_ty_2__bindgen_ty_653, pub _py_times: _Py_global_strings__bindgen_ty_2__bindgen_ty_654, pub _py_timetuple: _Py_global_strings__bindgen_ty_2__bindgen_ty_655, pub _py_top: _Py_global_strings__bindgen_ty_2__bindgen_ty_656, pub _py_trace_callback: _Py_global_strings__bindgen_ty_2__bindgen_ty_657, pub _py_traceback: _Py_global_strings__bindgen_ty_2__bindgen_ty_658, pub _py_trailers: _Py_global_strings__bindgen_ty_2__bindgen_ty_659, pub _py_translate: _Py_global_strings__bindgen_ty_2__bindgen_ty_660, pub _py_true: _Py_global_strings__bindgen_ty_2__bindgen_ty_661, pub _py_truncate: _Py_global_strings__bindgen_ty_2__bindgen_ty_662, pub _py_twice: _Py_global_strings__bindgen_ty_2__bindgen_ty_663, pub _py_txt: _Py_global_strings__bindgen_ty_2__bindgen_ty_664, pub _py_type: _Py_global_strings__bindgen_ty_2__bindgen_ty_665, pub _py_type_params: _Py_global_strings__bindgen_ty_2__bindgen_ty_666, pub _py_tz: _Py_global_strings__bindgen_ty_2__bindgen_ty_667, pub _py_tzname: _Py_global_strings__bindgen_ty_2__bindgen_ty_668, pub _py_uid: _Py_global_strings__bindgen_ty_2__bindgen_ty_669, pub _py_unlink: _Py_global_strings__bindgen_ty_2__bindgen_ty_670, pub _py_unraisablehook: _Py_global_strings__bindgen_ty_2__bindgen_ty_671, pub _py_uri: _Py_global_strings__bindgen_ty_2__bindgen_ty_672, pub _py_usedforsecurity: _Py_global_strings__bindgen_ty_2__bindgen_ty_673, pub _py_value: _Py_global_strings__bindgen_ty_2__bindgen_ty_674, pub _py_values: _Py_global_strings__bindgen_ty_2__bindgen_ty_675, pub _py_version: _Py_global_strings__bindgen_ty_2__bindgen_ty_676, pub _py_volume: _Py_global_strings__bindgen_ty_2__bindgen_ty_677, pub _py_warnings: _Py_global_strings__bindgen_ty_2__bindgen_ty_678, pub _py_warnoptions: _Py_global_strings__bindgen_ty_2__bindgen_ty_679, pub _py_wbits: _Py_global_strings__bindgen_ty_2__bindgen_ty_680, pub _py_week: _Py_global_strings__bindgen_ty_2__bindgen_ty_681, pub _py_weekday: _Py_global_strings__bindgen_ty_2__bindgen_ty_682, pub _py_which: _Py_global_strings__bindgen_ty_2__bindgen_ty_683, pub _py_who: _Py_global_strings__bindgen_ty_2__bindgen_ty_684, pub _py_withdata: _Py_global_strings__bindgen_ty_2__bindgen_ty_685, pub _py_writable: _Py_global_strings__bindgen_ty_2__bindgen_ty_686, pub _py_write: _Py_global_strings__bindgen_ty_2__bindgen_ty_687, pub _py_write_through: _Py_global_strings__bindgen_ty_2__bindgen_ty_688, pub _py_x: _Py_global_strings__bindgen_ty_2__bindgen_ty_689, pub _py_year: _Py_global_strings__bindgen_ty_2__bindgen_ty_690, pub _py_zdict: _Py_global_strings__bindgen_ty_2__bindgen_ty_691, } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_1 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_2 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_2 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_3 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_3 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_4 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_4 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_5 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_5 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_6 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_6 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_7 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_7 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_8 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_8 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_9 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_9 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_10 { pub _ascii: PyASCIIObject, pub _data: [u8; 2usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_10 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_11 { pub _ascii: PyASCIIObject, pub _data: [u8; 18usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_11 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_12 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_12 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_13 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_13 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_14 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_14 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_15 { pub _ascii: PyASCIIObject, pub _data: [u8; 20usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_15 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_16 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_16 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_17 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_17 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_18 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_18 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_19 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_19 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_20 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_20 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_21 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_21 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_22 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_22 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_23 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_23 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_24 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_24 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_25 { pub _ascii: PyASCIIObject, pub _data: [u8; 31usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_25 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_26 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_26 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_27 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_27 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_28 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_28 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_29 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_29 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_30 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_30 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_31 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_31 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_32 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_32 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_33 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_33 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_34 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_34 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_35 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_35 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_36 { pub _ascii: PyASCIIObject, pub _data: [u8; 18usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_36 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_37 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_37 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_38 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_38 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_39 { pub _ascii: PyASCIIObject, pub _data: [u8; 18usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_39 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_40 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_40 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_41 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_41 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_42 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_42 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_43 { pub _ascii: PyASCIIObject, pub _data: [u8; 25usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_43 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_44 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_44 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_45 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_45 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_46 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_46 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_47 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_47 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_48 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_48 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_49 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_49 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_50 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_50 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_51 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_51 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_52 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_52 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_53 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_53 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_54 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_54 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_55 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_55 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_56 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_56 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_57 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_57 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_58 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_58 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_59 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_59 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_60 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_60 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_61 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_61 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_62 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_62 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_63 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_63 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_64 { pub _ascii: PyASCIIObject, pub _data: [u8; 17usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_64 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_65 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_65 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_66 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_66 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_67 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_67 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_68 { pub _ascii: PyASCIIObject, pub _data: [u8; 18usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_68 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_69 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_69 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_70 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_70 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_71 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_71 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_72 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_72 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_73 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_73 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_74 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_74 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_75 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_75 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_76 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_76 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_77 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_77 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_78 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_78 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_79 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_79 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_80 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_80 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_81 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_81 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_82 { pub _ascii: PyASCIIObject, pub _data: [u8; 18usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_82 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_83 { pub _ascii: PyASCIIObject, pub _data: [u8; 18usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_83 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_84 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_84 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_85 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_85 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_86 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_86 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_87 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_87 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_88 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_88 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_89 { pub _ascii: PyASCIIObject, pub _data: [u8; 21usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_89 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_90 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_90 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_91 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_91 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_92 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_92 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_93 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_93 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_94 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_94 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_95 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_95 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_96 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_96 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_97 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_97 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_98 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_98 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_99 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_99 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_100 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_100 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_101 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_101 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_102 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_102 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_103 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_103 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_104 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_104 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_105 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_105 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_106 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_106 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_107 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_107 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_108 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_108 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_109 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_109 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_110 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_110 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_111 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_111 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_112 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_112 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_113 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_113 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_114 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_114 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_115 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_115 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_116 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_116 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_117 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_117 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_118 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_118 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_119 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_119 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_120 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_120 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_121 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_121 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_122 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_122 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_123 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_123 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_124 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_124 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_125 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_125 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_126 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_126 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_127 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_127 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_128 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_128 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_129 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_129 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_130 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_130 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_131 { pub _ascii: PyASCIIObject, pub _data: [u8; 19usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_131 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_132 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_132 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_133 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_133 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_134 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_134 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_135 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_135 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_136 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_136 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_137 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_137 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_138 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_138 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_139 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_139 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_140 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_140 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_141 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_141 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_142 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_142 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_143 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_143 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_144 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_144 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_145 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_145 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_146 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_146 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_147 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_147 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_148 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_148 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_149 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_149 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_150 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_150 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_151 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_151 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_152 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_152 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_153 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_153 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_154 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_154 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_155 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_155 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_156 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_156 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_157 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_157 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_158 { pub _ascii: PyASCIIObject, pub _data: [u8; 18usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_158 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_159 { pub _ascii: PyASCIIObject, pub _data: [u8; 17usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_159 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_160 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_160 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_161 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_161 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_162 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_162 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_163 { pub _ascii: PyASCIIObject, pub _data: [u8; 36usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_163 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_164 { pub _ascii: PyASCIIObject, pub _data: [u8; 25usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_164 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_165 { pub _ascii: PyASCIIObject, pub _data: [u8; 17usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_165 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_166 { pub _ascii: PyASCIIObject, pub _data: [u8; 31usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_166 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_167 { pub _ascii: PyASCIIObject, pub _data: [u8; 20usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_167 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_168 { pub _ascii: PyASCIIObject, pub _data: [u8; 19usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_168 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_169 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_169 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_170 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_170 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_171 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_171 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_172 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_172 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_173 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_173 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_174 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_174 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_175 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_175 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_176 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_176 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_177 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_177 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_178 { pub _ascii: PyASCIIObject, pub _data: [u8; 25usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_178 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_179 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_179 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_180 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_180 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_181 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_181 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_182 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_182 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_183 { pub _ascii: PyASCIIObject, pub _data: [u8; 17usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_183 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_184 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_184 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_185 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_185 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_186 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_186 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_187 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_187 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_188 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_188 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_189 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_189 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_190 { pub _ascii: PyASCIIObject, pub _data: [u8; 17usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_190 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_191 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_191 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_192 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_192 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_193 { pub _ascii: PyASCIIObject, pub _data: [u8; 18usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_193 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_194 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_194 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_195 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_195 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_196 { pub _ascii: PyASCIIObject, pub _data: [u8; 20usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_196 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_197 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_197 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_198 { pub _ascii: PyASCIIObject, pub _data: [u8; 19usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_198 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_199 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_199 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_200 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_200 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_201 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_201 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_202 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_202 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_203 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_203 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_204 { pub _ascii: PyASCIIObject, pub _data: [u8; 19usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_204 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_205 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_205 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_206 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_206 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_207 { pub _ascii: PyASCIIObject, pub _data: [u8; 26usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_207 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_208 { pub _ascii: PyASCIIObject, pub _data: [u8; 26usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_208 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_209 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_209 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_210 { pub _ascii: PyASCIIObject, pub _data: [u8; 2usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_210 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_211 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_211 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_212 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_212 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_213 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_213 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_214 { pub _ascii: PyASCIIObject, pub _data: [u8; 18usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_214 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_215 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_215 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_216 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_216 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_217 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_217 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_218 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_218 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_219 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_219 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_220 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_220 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_221 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_221 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_222 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_222 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_223 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_223 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_224 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_224 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_225 { pub _ascii: PyASCIIObject, pub _data: [u8; 17usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_225 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_226 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_226 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_227 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_227 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_228 { pub _ascii: PyASCIIObject, pub _data: [u8; 20usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_228 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_229 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_229 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_230 { pub _ascii: PyASCIIObject, pub _data: [u8; 2usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_230 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_231 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_231 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_232 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_232 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_233 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_233 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_234 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_234 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_235 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_235 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_236 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_236 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_237 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_237 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_238 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_238 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_239 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_239 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_240 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_240 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_241 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_241 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_242 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_242 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_243 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_243 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_244 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_244 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_245 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_245 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_246 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_246 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_247 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_247 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_248 { pub _ascii: PyASCIIObject, pub _data: [u8; 2usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_248 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_249 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_249 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_250 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_250 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_251 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_251 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_252 { pub _ascii: PyASCIIObject, pub _data: [u8; 18usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_252 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_253 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_253 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_254 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_254 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_255 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_255 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_256 { pub _ascii: PyASCIIObject, pub _data: [u8; 23usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_256 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_257 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_257 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_258 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_258 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_259 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_259 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_260 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_260 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_261 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_261 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_262 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_262 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_263 { pub _ascii: PyASCIIObject, pub _data: [u8; 18usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_263 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_264 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_264 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_265 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_265 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_266 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_266 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_267 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_267 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_268 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_268 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_269 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_269 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_270 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_270 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_271 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_271 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_272 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_272 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_273 { pub _ascii: PyASCIIObject, pub _data: [u8; 18usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_273 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_274 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_274 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_275 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_275 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_276 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_276 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_277 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_277 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_278 { pub _ascii: PyASCIIObject, pub _data: [u8; 18usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_278 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_279 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_279 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_280 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_280 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_281 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_281 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_282 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_282 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_283 { pub _ascii: PyASCIIObject, pub _data: [u8; 19usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_283 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_284 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_284 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_285 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_285 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_286 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_286 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_287 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_287 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_288 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_288 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_289 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_289 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_290 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_290 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_291 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_291 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_292 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_292 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_293 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_293 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_294 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_294 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_295 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_295 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_296 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_296 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_297 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_297 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_298 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_298 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_299 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_299 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_300 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_300 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_301 { pub _ascii: PyASCIIObject, pub _data: [u8; 2usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_301 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_302 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_302 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_303 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_303 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_304 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_304 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_305 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_305 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_306 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_306 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_307 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_307 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_308 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_308 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_309 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_309 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_310 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_310 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_311 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_311 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_312 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_312 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_313 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_313 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_314 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_314 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_315 { pub _ascii: PyASCIIObject, pub _data: [u8; 18usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_315 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_316 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_316 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_317 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_317 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_318 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_318 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_319 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_319 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_320 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_320 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_321 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_321 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_322 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_322 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_323 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_323 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_324 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_324 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_325 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_325 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_326 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_326 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_327 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_327 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_328 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_328 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_329 { pub _ascii: PyASCIIObject, pub _data: [u8; 2usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_329 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_330 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_330 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_331 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_331 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_332 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_332 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_333 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_333 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_334 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_334 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_335 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_335 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_336 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_336 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_337 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_337 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_338 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_338 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_339 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_339 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_340 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_340 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_341 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_341 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_342 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_342 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_343 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_343 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_344 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_344 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_345 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_345 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_346 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_346 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_347 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_347 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_348 { pub _ascii: PyASCIIObject, pub _data: [u8; 19usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_348 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_349 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_349 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_350 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_350 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_351 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_351 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_352 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_352 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_353 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_353 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_354 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_354 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_355 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_355 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_356 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_356 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_357 { pub _ascii: PyASCIIObject, pub _data: [u8; 3usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_357 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_358 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_358 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_359 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_359 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_360 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_360 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_361 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_361 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_362 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_362 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_363 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_363 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_364 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_364 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_365 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_365 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_366 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_366 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_367 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_367 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_368 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_368 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_369 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_369 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_370 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_370 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_371 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_371 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_372 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_372 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_373 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_373 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_374 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_374 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_375 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_375 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_376 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_376 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_377 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_377 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_378 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_378 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_379 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_379 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_380 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_380 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_381 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_381 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_382 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_382 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_383 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_383 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_384 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_384 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_385 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_385 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_386 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_386 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_387 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_387 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_388 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_388 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_389 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_389 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_390 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_390 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_391 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_391 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_392 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_392 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_393 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_393 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_394 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_394 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_395 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_395 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_396 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_396 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_397 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_397 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_398 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_398 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_399 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_399 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_400 { pub _ascii: PyASCIIObject, pub _data: [u8; 3usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_400 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_401 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_401 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_402 { pub _ascii: PyASCIIObject, pub _data: [u8; 3usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_402 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_403 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_403 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_404 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_404 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_405 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_405 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_406 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_406 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_407 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_407 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_408 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_408 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_409 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_409 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_410 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_410 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_411 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_411 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_412 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_412 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_413 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_413 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_414 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_414 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_415 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_415 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_416 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_416 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_417 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_417 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_418 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_418 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_419 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_419 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_420 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_420 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_421 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_421 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_422 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_422 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_423 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_423 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_424 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_424 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_425 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_425 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_426 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_426 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_427 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_427 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_428 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_428 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_429 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_429 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_430 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_430 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_431 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_431 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_432 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_432 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_433 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_433 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_434 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_434 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_435 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_435 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_436 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_436 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_437 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_437 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_438 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_438 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_439 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_439 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_440 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_440 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_441 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_441 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_442 { pub _ascii: PyASCIIObject, pub _data: [u8; 3usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_442 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_443 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_443 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_444 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_444 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_445 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_445 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_446 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_446 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_447 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_447 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_448 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_448 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_449 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_449 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_450 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_450 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_451 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_451 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_452 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_452 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_453 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_453 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_454 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_454 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_455 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_455 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_456 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_456 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_457 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_457 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_458 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_458 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_459 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_459 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_460 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_460 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_461 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_461 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_462 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_462 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_463 { pub _ascii: PyASCIIObject, pub _data: [u8; 3usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_463 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_464 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_464 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_465 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_465 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_466 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_466 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_467 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_467 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_468 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_468 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_469 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_469 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_470 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_470 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_471 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_471 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_472 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_472 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_473 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_473 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_474 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_474 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_475 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_475 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_476 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_476 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_477 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_477 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_478 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_478 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_479 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_479 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_480 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_480 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_481 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_481 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_482 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_482 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_483 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_483 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_484 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_484 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_485 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_485 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_486 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_486 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_487 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_487 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_488 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_488 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_489 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_489 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_490 { pub _ascii: PyASCIIObject, pub _data: [u8; 2usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_490 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_491 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_491 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_492 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_492 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_493 { pub _ascii: PyASCIIObject, pub _data: [u8; 18usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_493 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_494 { pub _ascii: PyASCIIObject, pub _data: [u8; 17usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_494 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_495 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_495 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_496 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_496 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_497 { pub _ascii: PyASCIIObject, pub _data: [u8; 20usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_497 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_498 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_498 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_499 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_499 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_500 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_500 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_501 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_501 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_502 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_502 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_503 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_503 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_504 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_504 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_505 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_505 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_506 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_506 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_507 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_507 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_508 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_508 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_509 { pub _ascii: PyASCIIObject, pub _data: [u8; 3usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_509 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_510 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_510 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_511 { pub _ascii: PyASCIIObject, pub _data: [u8; 3usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_511 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_512 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_512 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_513 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_513 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_514 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_514 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_515 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_515 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_516 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_516 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_517 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_517 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_518 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_518 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_519 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_519 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_520 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_520 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_521 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_521 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_522 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_522 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_523 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_523 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_524 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_524 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_525 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_525 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_526 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_526 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_527 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_527 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_528 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_528 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_529 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_529 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_530 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_530 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_531 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_531 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_532 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_532 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_533 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_533 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_534 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_534 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_535 { pub _ascii: PyASCIIObject, pub _data: [u8; 2usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_535 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_536 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_536 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_537 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_537 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_538 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_538 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_539 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_539 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_540 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_540 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_541 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_541 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_542 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_542 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_543 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_543 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_544 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_544 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_545 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_545 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_546 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_546 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_547 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_547 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_548 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_548 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_549 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_549 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_550 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_550 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_551 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_551 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_552 { pub _ascii: PyASCIIObject, pub _data: [u8; 20usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_552 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_553 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_553 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_554 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_554 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_555 { pub _ascii: PyASCIIObject, pub _data: [u8; 17usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_555 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_556 { pub _ascii: PyASCIIObject, pub _data: [u8; 17usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_556 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_557 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_557 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_558 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_558 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_559 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_559 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_560 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_560 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_561 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_561 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_562 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_562 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_563 { pub _ascii: PyASCIIObject, pub _data: [u8; 2usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_563 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_564 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_564 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_565 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_565 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_566 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_566 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_567 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_567 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_568 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_568 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_569 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_569 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_570 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_570 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_571 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_571 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_572 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_572 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_573 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_573 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_574 { pub _ascii: PyASCIIObject, pub _data: [u8; 17usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_574 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_575 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_575 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_576 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_576 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_577 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_577 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_578 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_578 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_579 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_579 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_580 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_580 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_581 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_581 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_582 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_582 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_583 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_583 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_584 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_584 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_585 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_585 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_586 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_586 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_587 { pub _ascii: PyASCIIObject, pub _data: [u8; 2usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_587 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_588 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_588 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_589 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_589 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_590 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_590 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_591 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_591 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_592 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_592 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_593 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_593 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_594 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_594 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_595 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_595 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_596 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_596 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_597 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_597 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_598 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_598 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_599 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_599 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_600 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_600 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_601 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_601 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_602 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_602 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_603 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_603 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_604 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_604 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_605 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_605 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_606 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_606 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_607 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_607 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_608 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_608 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_609 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_609 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_610 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_610 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_611 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_611 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_612 { pub _ascii: PyASCIIObject, pub _data: [u8; 19usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_612 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_613 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_613 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_614 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_614 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_615 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_615 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_616 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_616 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_617 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_617 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_618 { pub _ascii: PyASCIIObject, pub _data: [u8; 17usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_618 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_619 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_619 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_620 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_620 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_621 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_621 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_622 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_622 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_623 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_623 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_624 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_624 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_625 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_625 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_626 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_626 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_627 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_627 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_628 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_628 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_629 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_629 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_630 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_630 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_631 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_631 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_632 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_632 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_633 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_633 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_634 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_634 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_635 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_635 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_636 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_636 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_637 { pub _ascii: PyASCIIObject, pub _data: [u8; 28usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_637 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_638 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_638 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_639 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_639 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_640 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_640 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_641 { pub _ascii: PyASCIIObject, pub _data: [u8; 20usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_641 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_642 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_642 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_643 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_643 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_644 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_644 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_645 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_645 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_646 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_646 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_647 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_647 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_648 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_648 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_649 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_649 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_650 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_650 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_651 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_651 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_652 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_652 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_653 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_653 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_654 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_654 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_655 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_655 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_656 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_656 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_657 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_657 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_658 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_658 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_659 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_659 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_660 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_660 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_661 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_661 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_662 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_662 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_663 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_663 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_664 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_664 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_665 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_665 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_666 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_666 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_667 { pub _ascii: PyASCIIObject, pub _data: [u8; 3usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_667 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_668 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_668 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_669 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_669 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_670 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_670 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_671 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_671 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_672 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_672 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_673 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_673 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_674 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_674 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_675 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_675 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_676 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_676 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_677 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_677 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_678 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_678 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_679 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_679 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_680 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_680 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_681 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_681 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_682 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_682 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_683 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_683 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_684 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_684 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_685 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_685 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_686 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_686 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_687 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_687 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_688 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_688 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_689 { pub _ascii: PyASCIIObject, pub _data: [u8; 2usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_689 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_690 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_690 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_691 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_691 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } impl Default for _Py_global_strings__bindgen_ty_2 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_3 { pub _ascii: PyASCIIObject, pub _data: [u8; 2usize], } impl Default for _Py_global_strings__bindgen_ty_3 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_4 { pub _latin1: PyCompactUnicodeObject, pub _data: [u8; 2usize], } impl Default for _Py_global_strings__bindgen_ty_4 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } impl Default for _Py_global_strings { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _types_runtime_state { pub next_version_tag: ::std::os::raw::c_uint, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct type_cache_entry { pub version: ::std::os::raw::c_uint, pub name: *mut PyObject, pub value: *mut PyObject, } impl Default for type_cache_entry { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct type_cache { pub hashtable: [type_cache_entry; 4096usize], } impl Default for type_cache { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct static_builtin_state { pub type_: *mut PyTypeObject, pub readying: ::std::os::raw::c_int, pub ready: ::std::os::raw::c_int, pub tp_dict: *mut PyObject, pub tp_subclasses: *mut PyObject, pub tp_weaklist: *mut PyObject, } impl Default for static_builtin_state { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct types_state { pub next_version_tag: ::std::os::raw::c_uint, pub type_cache: type_cache, pub num_builtins_initialized: usize, pub builtins: [static_builtin_state; 200usize], } impl Default for types_state { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type pytype_slotdef = wrapperbase; #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_static_objects { pub singletons: _Py_static_objects__bindgen_ty_1, } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_static_objects__bindgen_ty_1 { pub small_ints: [PyLongObject; 262usize], pub bytes_empty: PyBytesObject, pub bytes_characters: [_Py_static_objects__bindgen_ty_1__bindgen_ty_1; 256usize], pub strings: _Py_global_strings, pub _tuple_empty_gc_not_used: PyGC_Head, pub tuple_empty: PyTupleObject, pub _hamt_bitmap_node_empty_gc_not_used: PyGC_Head, pub hamt_bitmap_node_empty: PyHamtNode_Bitmap, pub context_token_missing: _PyContextTokenMissing, } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_static_objects__bindgen_ty_1__bindgen_ty_1 { pub ob: PyBytesObject, pub eos: ::std::os::raw::c_char, } impl Default for _Py_static_objects__bindgen_ty_1__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } impl Default for _Py_static_objects__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } impl Default for _Py_static_objects { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_interp_cached_objects { pub interned_strings: *mut PyObject, pub str_replace_inf: *mut PyObject, pub objreduce: *mut PyObject, pub type_slots_pname: *mut PyObject, pub type_slots_ptrs: [*mut pytype_slotdef; 10usize], pub generic_type: *mut PyTypeObject, pub typevar_type: *mut PyTypeObject, pub typevartuple_type: *mut PyTypeObject, pub paramspec_type: *mut PyTypeObject, pub paramspecargs_type: *mut PyTypeObject, pub paramspeckwargs_type: *mut PyTypeObject, } impl Default for _Py_interp_cached_objects { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_interp_static_objects { pub singletons: _Py_interp_static_objects__bindgen_ty_1, } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_interp_static_objects__bindgen_ty_1 { pub _not_used: ::std::os::raw::c_int, pub _hamt_empty_gc_not_used: PyGC_Head, pub hamt_empty: PyHamtObject, pub last_resort_memory_error: PyBaseExceptionObject, } impl Default for _Py_interp_static_objects__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } impl Default for _Py_interp_static_objects { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_slist_item_s { pub next: *mut _Py_slist_item_s, } impl Default for _Py_slist_item_s { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type _Py_slist_item_t = _Py_slist_item_s; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_slist_t { pub head: *mut _Py_slist_item_t, } impl Default for _Py_slist_t { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_hashtable_entry_t { pub _Py_slist_item: _Py_slist_item_t, pub key_hash: Py_uhash_t, pub key: *mut ::std::os::raw::c_void, pub value: *mut ::std::os::raw::c_void, } impl Default for _Py_hashtable_entry_t { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type _Py_hashtable_hash_func = ::std::option::Option Py_uhash_t>; pub type _Py_hashtable_compare_func = ::std::option::Option< unsafe extern "C" fn( key1: *const ::std::os::raw::c_void, key2: *const ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; pub type _Py_hashtable_destroy_func = ::std::option::Option; pub type _Py_hashtable_get_entry_func = ::std::option::Option< unsafe extern "C" fn( ht: *mut _Py_hashtable_t, key: *const ::std::os::raw::c_void, ) -> *mut _Py_hashtable_entry_t, >; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_hashtable_allocator_t { pub malloc: ::std::option::Option *mut ::std::os::raw::c_void>, pub free: ::std::option::Option, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_hashtable_t { pub nentries: usize, pub nbuckets: usize, pub buckets: *mut _Py_slist_t, pub get_entry_func: _Py_hashtable_get_entry_func, pub hash_func: _Py_hashtable_hash_func, pub compare_func: _Py_hashtable_compare_func, pub key_destroy_func: _Py_hashtable_destroy_func, pub value_destroy_func: _Py_hashtable_destroy_func, pub alloc: _Py_hashtable_allocator_t, } impl Default for _Py_hashtable_t { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _time_runtime_state { pub ticks_per_second_initialized: ::std::os::raw::c_int, pub ticks_per_second: ::std::os::raw::c_long, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _import_runtime_state { pub inittab: *mut _inittab, pub last_module_index: Py_ssize_t, pub extensions: _import_runtime_state__bindgen_ty_1, pub pkgcontext: *const ::std::os::raw::c_char, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _import_runtime_state__bindgen_ty_1 { pub mutex: PyThread_type_lock, pub hashtable: *mut _Py_hashtable_t, } impl Default for _import_runtime_state__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } impl Default for _import_runtime_state { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _import_state { pub modules: *mut PyObject, pub modules_by_index: *mut PyObject, pub importlib: *mut PyObject, pub override_frozen_modules: ::std::os::raw::c_int, pub override_multi_interp_extensions_check: ::std::os::raw::c_int, pub dlopenflags: ::std::os::raw::c_int, pub import_func: *mut PyObject, pub lock: _import_state__bindgen_ty_1, pub find_and_load: _import_state__bindgen_ty_2, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _import_state__bindgen_ty_1 { pub mutex: PyThread_type_lock, pub thread: ::std::os::raw::c_ulong, pub level: ::std::os::raw::c_int, } impl Default for _import_state__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _import_state__bindgen_ty_2 { pub import_level: ::std::os::raw::c_int, pub accumulated: _PyTime_t, pub header: ::std::os::raw::c_int, } impl Default for _import_state { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _frame { pub ob_base: PyObject, pub f_back: *mut PyFrameObject, pub f_frame: *mut _PyInterpreterFrame, pub f_trace: *mut PyObject, pub f_lineno: ::std::os::raw::c_int, pub f_trace_lines: ::std::os::raw::c_char, pub f_trace_opcodes: ::std::os::raw::c_char, pub f_fast_as_locals: ::std::os::raw::c_char, pub _f_frame_data: [*mut PyObject; 1usize], } impl Default for _frame { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _PyInterpreterFrame { pub f_code: *mut PyCodeObject, pub previous: *mut _PyInterpreterFrame, pub f_funcobj: *mut PyObject, pub f_globals: *mut PyObject, pub f_builtins: *mut PyObject, pub f_locals: *mut PyObject, pub frame_obj: *mut PyFrameObject, pub prev_instr: *mut _Py_CODEUNIT, pub stacktop: ::std::os::raw::c_int, pub return_offset: u16, pub owner: ::std::os::raw::c_char, pub localsplus: [*mut PyObject; 1usize], } impl Default for _PyInterpreterFrame { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_list_state {} #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _py_object_runtime_state { pub _not_used: ::std::os::raw::c_int, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _py_object_state { pub _not_used: ::std::os::raw::c_int, } pub type pymem_uint = ::std::os::raw::c_uint; pub type pymem_block = u8; #[repr(C)] #[derive(Copy, Clone)] pub struct pool_header { pub ref_: pool_header__bindgen_ty_1, pub freeblock: *mut pymem_block, pub nextpool: *mut pool_header, pub prevpool: *mut pool_header, pub arenaindex: pymem_uint, pub szidx: pymem_uint, pub nextoffset: pymem_uint, pub maxnextoffset: pymem_uint, } #[repr(C)] #[derive(Copy, Clone)] pub union pool_header__bindgen_ty_1 { pub _padding: *mut pymem_block, pub count: pymem_uint, } impl Default for pool_header__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } impl Default for pool_header { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type poolp = *mut pool_header; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct arena_object { pub address: usize, pub pool_address: *mut pymem_block, pub nfreepools: pymem_uint, pub ntotalpools: pymem_uint, pub freepools: *mut pool_header, pub nextarena: *mut arena_object, pub prevarena: *mut arena_object, } impl Default for arena_object { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _obmalloc_pools { pub used: [poolp; 64usize], } impl Default for _obmalloc_pools { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _obmalloc_mgmt { pub arenas: *mut arena_object, pub maxarenas: pymem_uint, pub unused_arena_objects: *mut arena_object, pub usable_arenas: *mut arena_object, pub nfp2lasta: [*mut arena_object; 65usize], pub narenas_currently_allocated: usize, pub ntimes_arena_allocated: usize, pub narenas_highwater: usize, pub raw_allocated_blocks: Py_ssize_t, } impl Default for _obmalloc_mgmt { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct arena_coverage_t { pub tail_hi: i32, pub tail_lo: i32, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct arena_map_bot { pub arenas: [arena_coverage_t; 16384usize], } impl Default for arena_map_bot { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct arena_map_mid { pub ptrs: [*mut arena_map_bot; 32768usize], } impl Default for arena_map_mid { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct arena_map_top { pub ptrs: [*mut arena_map_mid; 32768usize], } impl Default for arena_map_top { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type arena_map_top_t = arena_map_top; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _obmalloc_usage { pub arena_map_root: arena_map_top_t, pub arena_map_mid_count: ::std::os::raw::c_int, pub arena_map_bot_count: ::std::os::raw::c_int, } impl Default for _obmalloc_usage { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _obmalloc_global_state { pub dump_debug_stats: ::std::os::raw::c_int, pub interpreter_leaks: Py_ssize_t, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _obmalloc_state { pub pools: _obmalloc_pools, pub mgmt: _obmalloc_mgmt, pub usage: _obmalloc_usage, } impl Default for _obmalloc_state { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_tuple_state { pub _unused: ::std::os::raw::c_char, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _fileutils_state { pub force_ascii: ::std::os::raw::c_int, } pub const _Py_error_handler__Py_ERROR_UNKNOWN: _Py_error_handler = 0; pub const _Py_error_handler__Py_ERROR_STRICT: _Py_error_handler = 1; pub const _Py_error_handler__Py_ERROR_SURROGATEESCAPE: _Py_error_handler = 2; pub const _Py_error_handler__Py_ERROR_REPLACE: _Py_error_handler = 3; pub const _Py_error_handler__Py_ERROR_IGNORE: _Py_error_handler = 4; pub const _Py_error_handler__Py_ERROR_BACKSLASHREPLACE: _Py_error_handler = 5; pub const _Py_error_handler__Py_ERROR_SURROGATEPASS: _Py_error_handler = 6; pub const _Py_error_handler__Py_ERROR_XMLCHARREFREPLACE: _Py_error_handler = 7; pub const _Py_error_handler__Py_ERROR_OTHER: _Py_error_handler = 8; pub type _Py_error_handler = ::std::os::raw::c_uint; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _PyUnicode_Name_CAPI { pub getname: ::std::option::Option< unsafe extern "C" fn( code: Py_UCS4, buffer: *mut ::std::os::raw::c_char, buflen: ::std::os::raw::c_int, with_alias_and_seq: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >, pub getcode: ::std::option::Option< unsafe extern "C" fn( name: *const ::std::os::raw::c_char, namelen: ::std::os::raw::c_int, code: *mut Py_UCS4, with_named_seq: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_unicode_runtime_ids { pub lock: PyThread_type_lock, pub next_index: Py_ssize_t, } impl Default for _Py_unicode_runtime_ids { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_unicode_runtime_state { pub ids: _Py_unicode_runtime_ids, } impl Default for _Py_unicode_runtime_state { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_unicode_fs_codec { pub encoding: *mut ::std::os::raw::c_char, pub utf8: ::std::os::raw::c_int, pub errors: *mut ::std::os::raw::c_char, pub error_handler: _Py_error_handler, } impl Default for _Py_unicode_fs_codec { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_unicode_ids { pub size: Py_ssize_t, pub array: *mut *mut PyObject, } impl Default for _Py_unicode_ids { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_unicode_state { pub fs_codec: _Py_unicode_fs_codec, pub ucnhash_capi: *mut _PyUnicode_Name_CAPI, pub ids: _Py_unicode_ids, } impl Default for _Py_unicode_state { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _warnings_runtime_state { pub filters: *mut PyObject, pub once_registry: *mut PyObject, pub default_action: *mut PyObject, pub filters_version: ::std::os::raw::c_long, } impl Default for _warnings_runtime_state { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_long_state { pub max_str_digits: ::std::os::raw::c_int, } #[repr(C)] #[derive(Copy, Clone)] pub struct _is { pub next: *mut PyInterpreterState, pub id: i64, pub id_refcount: i64, pub requires_idref: ::std::os::raw::c_int, pub id_mutex: PyThread_type_lock, pub _initialized: ::std::os::raw::c_int, pub finalizing: ::std::os::raw::c_int, pub monitoring_version: u64, pub last_restart_version: u64, pub threads: _is_pythreads, pub runtime: *mut pyruntimestate, pub _finalizing: _Py_atomic_address, pub gc: _gc_runtime_state, pub sysdict: *mut PyObject, pub builtins: *mut PyObject, pub ceval: _ceval_state, pub imports: _import_state, pub _gil: _gil_runtime_state, pub codec_search_path: *mut PyObject, pub codec_search_cache: *mut PyObject, pub codec_error_registry: *mut PyObject, pub codecs_initialized: ::std::os::raw::c_int, pub config: PyConfig, pub feature_flags: ::std::os::raw::c_ulong, pub dict: *mut PyObject, pub sysdict_copy: *mut PyObject, pub builtins_copy: *mut PyObject, pub eval_frame: _PyFrameEvalFunction, pub func_watchers: [PyFunction_WatchCallback; 8usize], pub active_func_watchers: u8, pub co_extra_user_count: Py_ssize_t, pub co_extra_freefuncs: [freefunc; 255usize], pub before_forkers: *mut PyObject, pub after_forkers_parent: *mut PyObject, pub after_forkers_child: *mut PyObject, pub warnings: _warnings_runtime_state, pub atexit: atexit_state, pub obmalloc: _obmalloc_state, pub audit_hooks: *mut PyObject, pub type_watchers: [PyType_WatchCallback; 8usize], pub code_watchers: [PyCode_WatchCallback; 8usize], pub active_code_watchers: u8, pub object_state: _py_object_state, pub unicode: _Py_unicode_state, pub float_state: _Py_float_state, pub long_state: _Py_long_state, pub dtoa: _dtoa_state, pub func_state: _py_func_state, pub slice_cache: *mut PySliceObject, pub tuple: _Py_tuple_state, pub list: _Py_list_state, pub dict_state: _Py_dict_state, pub async_gen: _Py_async_gen_state, pub context: _Py_context_state, pub exc_state: _Py_exc_state, pub ast: ast_state, pub types: types_state, pub callable_cache: callable_cache, pub interpreter_trampoline: *mut PyCodeObject, pub monitors: _Py_GlobalMonitors, pub f_opcode_trace_set: bool, pub sys_profile_initialized: bool, pub sys_trace_initialized: bool, pub sys_profiling_threads: Py_ssize_t, pub sys_tracing_threads: Py_ssize_t, pub monitoring_callables: [[*mut PyObject; 17usize]; 8usize], pub monitoring_tool_names: [*mut PyObject; 8usize], pub cached_objects: _Py_interp_cached_objects, pub static_objects: _Py_interp_static_objects, pub _initial_thread: PyThreadState, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _is_pythreads { pub next_unique_id: u64, pub head: *mut PyThreadState, pub count: ::std::os::raw::c_long, pub stacksize: usize, } impl Default for _is_pythreads { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } impl Default for _is { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _xidregitem { pub prev: *mut _xidregitem, pub next: *mut _xidregitem, pub cls: *mut PyObject, pub getdata: crossinterpdatafunc, } impl Default for _xidregitem { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type sig_atomic_t = __sig_atomic_t; #[repr(C)] #[derive(Copy, Clone)] pub union sigval { pub sival_int: ::std::os::raw::c_int, pub sival_ptr: *mut ::std::os::raw::c_void, } impl Default for sigval { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type __sigval_t = sigval; #[repr(C)] #[derive(Copy, Clone)] pub struct siginfo_t { pub si_signo: ::std::os::raw::c_int, pub si_errno: ::std::os::raw::c_int, pub si_code: ::std::os::raw::c_int, pub __pad0: ::std::os::raw::c_int, pub _sifields: siginfo_t__bindgen_ty_1, } #[repr(C)] #[derive(Copy, Clone)] pub union siginfo_t__bindgen_ty_1 { pub _pad: [::std::os::raw::c_int; 28usize], pub _kill: siginfo_t__bindgen_ty_1__bindgen_ty_1, pub _timer: siginfo_t__bindgen_ty_1__bindgen_ty_2, pub _rt: siginfo_t__bindgen_ty_1__bindgen_ty_3, pub _sigchld: siginfo_t__bindgen_ty_1__bindgen_ty_4, pub _sigfault: siginfo_t__bindgen_ty_1__bindgen_ty_5, pub _sigpoll: siginfo_t__bindgen_ty_1__bindgen_ty_6, pub _sigsys: siginfo_t__bindgen_ty_1__bindgen_ty_7, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct siginfo_t__bindgen_ty_1__bindgen_ty_1 { pub si_pid: __pid_t, pub si_uid: __uid_t, } #[repr(C)] #[derive(Copy, Clone)] pub struct siginfo_t__bindgen_ty_1__bindgen_ty_2 { pub si_tid: ::std::os::raw::c_int, pub si_overrun: ::std::os::raw::c_int, pub si_sigval: __sigval_t, } impl Default for siginfo_t__bindgen_ty_1__bindgen_ty_2 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct siginfo_t__bindgen_ty_1__bindgen_ty_3 { pub si_pid: __pid_t, pub si_uid: __uid_t, pub si_sigval: __sigval_t, } impl Default for siginfo_t__bindgen_ty_1__bindgen_ty_3 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct siginfo_t__bindgen_ty_1__bindgen_ty_4 { pub si_pid: __pid_t, pub si_uid: __uid_t, pub si_status: ::std::os::raw::c_int, pub si_utime: __clock_t, pub si_stime: __clock_t, } #[repr(C)] #[derive(Copy, Clone)] pub struct siginfo_t__bindgen_ty_1__bindgen_ty_5 { pub si_addr: *mut ::std::os::raw::c_void, pub si_addr_lsb: ::std::os::raw::c_short, pub _bounds: siginfo_t__bindgen_ty_1__bindgen_ty_5__bindgen_ty_1, } #[repr(C)] #[derive(Copy, Clone)] pub union siginfo_t__bindgen_ty_1__bindgen_ty_5__bindgen_ty_1 { pub _addr_bnd: siginfo_t__bindgen_ty_1__bindgen_ty_5__bindgen_ty_1__bindgen_ty_1, pub _pkey: __uint32_t, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct siginfo_t__bindgen_ty_1__bindgen_ty_5__bindgen_ty_1__bindgen_ty_1 { pub _lower: *mut ::std::os::raw::c_void, pub _upper: *mut ::std::os::raw::c_void, } impl Default for siginfo_t__bindgen_ty_1__bindgen_ty_5__bindgen_ty_1__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } impl Default for siginfo_t__bindgen_ty_1__bindgen_ty_5__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } impl Default for siginfo_t__bindgen_ty_1__bindgen_ty_5 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct siginfo_t__bindgen_ty_1__bindgen_ty_6 { pub si_band: ::std::os::raw::c_long, pub si_fd: ::std::os::raw::c_int, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct siginfo_t__bindgen_ty_1__bindgen_ty_7 { pub _call_addr: *mut ::std::os::raw::c_void, pub _syscall: ::std::os::raw::c_int, pub _arch: ::std::os::raw::c_uint, } impl Default for siginfo_t__bindgen_ty_1__bindgen_ty_7 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } impl Default for siginfo_t__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } impl Default for siginfo_t { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type __sighandler_t = ::std::option::Option; #[repr(C)] #[derive(Copy, Clone)] pub struct sigaction { pub __sigaction_handler: sigaction__bindgen_ty_1, pub sa_mask: __sigset_t, pub sa_flags: ::std::os::raw::c_int, pub sa_restorer: ::std::option::Option, } #[repr(C)] #[derive(Copy, Clone)] pub union sigaction__bindgen_ty_1 { pub sa_handler: __sighandler_t, pub sa_sigaction: ::std::option::Option< unsafe extern "C" fn( arg1: ::std::os::raw::c_int, arg2: *mut siginfo_t, arg3: *mut ::std::os::raw::c_void, ), >, } impl Default for sigaction__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } impl Default for sigaction { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct stack_t { pub ss_sp: *mut ::std::os::raw::c_void, pub ss_flags: ::std::os::raw::c_int, pub ss_size: usize, } impl Default for stack_t { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type _Py_sighandler_t = sigaction; #[repr(C)] #[derive(Copy, Clone)] pub struct faulthandler_user_signal { pub enabled: ::std::os::raw::c_int, pub file: *mut PyObject, pub fd: ::std::os::raw::c_int, pub all_threads: ::std::os::raw::c_int, pub chain: ::std::os::raw::c_int, pub previous: _Py_sighandler_t, pub interp: *mut PyInterpreterState, } impl Default for faulthandler_user_signal { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _faulthandler_runtime_state { pub fatal_error: _faulthandler_runtime_state__bindgen_ty_1, pub thread: _faulthandler_runtime_state__bindgen_ty_2, pub user_signals: *mut faulthandler_user_signal, pub stack: stack_t, pub old_stack: stack_t, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _faulthandler_runtime_state__bindgen_ty_1 { pub enabled: ::std::os::raw::c_int, pub file: *mut PyObject, pub fd: ::std::os::raw::c_int, pub all_threads: ::std::os::raw::c_int, pub interp: *mut PyInterpreterState, } impl Default for _faulthandler_runtime_state__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _faulthandler_runtime_state__bindgen_ty_2 { pub file: *mut PyObject, pub fd: ::std::os::raw::c_int, pub timeout_us: ::std::os::raw::c_longlong, pub repeat: ::std::os::raw::c_int, pub interp: *mut PyInterpreterState, pub exit: ::std::os::raw::c_int, pub header: *mut ::std::os::raw::c_char, pub header_len: usize, pub cancel_event: PyThread_type_lock, pub running: PyThread_type_lock, } impl Default for _faulthandler_runtime_state__bindgen_ty_2 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } impl Default for _faulthandler_runtime_state { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type identifier = *mut PyObject; pub type string = *mut PyObject; pub type constant = *mut PyObject; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct asdl_int_seq { pub size: Py_ssize_t, pub elements: *mut *mut ::std::os::raw::c_void, pub typed_elements: [::std::os::raw::c_int; 1usize], } impl Default for asdl_int_seq { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub type expr_ty = *mut _expr; pub const _expr_context_Load: _expr_context = 1; pub const _expr_context_Store: _expr_context = 2; pub const _expr_context_Del: _expr_context = 3; pub type _expr_context = ::std::os::raw::c_uint; pub use self::_expr_context as expr_context_ty; pub const _boolop_And: _boolop = 1; pub const _boolop_Or: _boolop = 2; pub type _boolop = ::std::os::raw::c_uint; pub use self::_boolop as boolop_ty; pub const _operator_Add: _operator = 1; pub const _operator_Sub: _operator = 2; pub const _operator_Mult: _operator = 3; pub const _operator_MatMult: _operator = 4; pub const _operator_Div: _operator = 5; pub const _operator_Mod: _operator = 6; pub const _operator_Pow: _operator = 7; pub const _operator_LShift: _operator = 8; pub const _operator_RShift: _operator = 9; pub const _operator_BitOr: _operator = 10; pub const _operator_BitXor: _operator = 11; pub const _operator_BitAnd: _operator = 12; pub const _operator_FloorDiv: _operator = 13; pub type _operator = ::std::os::raw::c_uint; pub use self::_operator as operator_ty; pub const _unaryop_Invert: _unaryop = 1; pub const _unaryop_Not: _unaryop = 2; pub const _unaryop_UAdd: _unaryop = 3; pub const _unaryop_USub: _unaryop = 4; pub type _unaryop = ::std::os::raw::c_uint; pub use self::_unaryop as unaryop_ty; pub type comprehension_ty = *mut _comprehension; pub type arguments_ty = *mut _arguments; pub type arg_ty = *mut _arg; pub type keyword_ty = *mut _keyword; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct asdl_expr_seq { pub size: Py_ssize_t, pub elements: *mut *mut ::std::os::raw::c_void, pub typed_elements: [expr_ty; 1usize], } impl Default for asdl_expr_seq { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct asdl_comprehension_seq { pub size: Py_ssize_t, pub elements: *mut *mut ::std::os::raw::c_void, pub typed_elements: [comprehension_ty; 1usize], } impl Default for asdl_comprehension_seq { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct asdl_arg_seq { pub size: Py_ssize_t, pub elements: *mut *mut ::std::os::raw::c_void, pub typed_elements: [arg_ty; 1usize], } impl Default for asdl_arg_seq { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct asdl_keyword_seq { pub size: Py_ssize_t, pub elements: *mut *mut ::std::os::raw::c_void, pub typed_elements: [keyword_ty; 1usize], } impl Default for asdl_keyword_seq { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } pub const _expr_kind_BoolOp_kind: _expr_kind = 1; pub const _expr_kind_NamedExpr_kind: _expr_kind = 2; pub const _expr_kind_BinOp_kind: _expr_kind = 3; pub const _expr_kind_UnaryOp_kind: _expr_kind = 4; pub const _expr_kind_Lambda_kind: _expr_kind = 5; pub const _expr_kind_IfExp_kind: _expr_kind = 6; pub const _expr_kind_Dict_kind: _expr_kind = 7; pub const _expr_kind_Set_kind: _expr_kind = 8; pub const _expr_kind_ListComp_kind: _expr_kind = 9; pub const _expr_kind_SetComp_kind: _expr_kind = 10; pub const _expr_kind_DictComp_kind: _expr_kind = 11; pub const _expr_kind_GeneratorExp_kind: _expr_kind = 12; pub const _expr_kind_Await_kind: _expr_kind = 13; pub const _expr_kind_Yield_kind: _expr_kind = 14; pub const _expr_kind_YieldFrom_kind: _expr_kind = 15; pub const _expr_kind_Compare_kind: _expr_kind = 16; pub const _expr_kind_Call_kind: _expr_kind = 17; pub const _expr_kind_FormattedValue_kind: _expr_kind = 18; pub const _expr_kind_JoinedStr_kind: _expr_kind = 19; pub const _expr_kind_Constant_kind: _expr_kind = 20; pub const _expr_kind_Attribute_kind: _expr_kind = 21; pub const _expr_kind_Subscript_kind: _expr_kind = 22; pub const _expr_kind_Starred_kind: _expr_kind = 23; pub const _expr_kind_Name_kind: _expr_kind = 24; pub const _expr_kind_List_kind: _expr_kind = 25; pub const _expr_kind_Tuple_kind: _expr_kind = 26; pub const _expr_kind_Slice_kind: _expr_kind = 27; pub type _expr_kind = ::std::os::raw::c_uint; #[repr(C)] #[derive(Copy, Clone)] pub struct _expr { pub kind: _expr_kind, pub v: _expr__bindgen_ty_1, pub lineno: ::std::os::raw::c_int, pub col_offset: ::std::os::raw::c_int, pub end_lineno: ::std::os::raw::c_int, pub end_col_offset: ::std::os::raw::c_int, } #[repr(C)] #[derive(Copy, Clone)] pub union _expr__bindgen_ty_1 { pub BoolOp: _expr__bindgen_ty_1__bindgen_ty_1, pub NamedExpr: _expr__bindgen_ty_1__bindgen_ty_2, pub BinOp: _expr__bindgen_ty_1__bindgen_ty_3, pub UnaryOp: _expr__bindgen_ty_1__bindgen_ty_4, pub Lambda: _expr__bindgen_ty_1__bindgen_ty_5, pub IfExp: _expr__bindgen_ty_1__bindgen_ty_6, pub Dict: _expr__bindgen_ty_1__bindgen_ty_7, pub Set: _expr__bindgen_ty_1__bindgen_ty_8, pub ListComp: _expr__bindgen_ty_1__bindgen_ty_9, pub SetComp: _expr__bindgen_ty_1__bindgen_ty_10, pub DictComp: _expr__bindgen_ty_1__bindgen_ty_11, pub GeneratorExp: _expr__bindgen_ty_1__bindgen_ty_12, pub Await: _expr__bindgen_ty_1__bindgen_ty_13, pub Yield: _expr__bindgen_ty_1__bindgen_ty_14, pub YieldFrom: _expr__bindgen_ty_1__bindgen_ty_15, pub Compare: _expr__bindgen_ty_1__bindgen_ty_16, pub Call: _expr__bindgen_ty_1__bindgen_ty_17, pub FormattedValue: _expr__bindgen_ty_1__bindgen_ty_18, pub JoinedStr: _expr__bindgen_ty_1__bindgen_ty_19, pub Constant: _expr__bindgen_ty_1__bindgen_ty_20, pub Attribute: _expr__bindgen_ty_1__bindgen_ty_21, pub Subscript: _expr__bindgen_ty_1__bindgen_ty_22, pub Starred: _expr__bindgen_ty_1__bindgen_ty_23, pub Name: _expr__bindgen_ty_1__bindgen_ty_24, pub List: _expr__bindgen_ty_1__bindgen_ty_25, pub Tuple: _expr__bindgen_ty_1__bindgen_ty_26, pub Slice: _expr__bindgen_ty_1__bindgen_ty_27, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_1 { pub op: boolop_ty, pub values: *mut asdl_expr_seq, } impl Default for _expr__bindgen_ty_1__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_2 { pub target: expr_ty, pub value: expr_ty, } impl Default for _expr__bindgen_ty_1__bindgen_ty_2 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_3 { pub left: expr_ty, pub op: operator_ty, pub right: expr_ty, } impl Default for _expr__bindgen_ty_1__bindgen_ty_3 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_4 { pub op: unaryop_ty, pub operand: expr_ty, } impl Default for _expr__bindgen_ty_1__bindgen_ty_4 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_5 { pub args: arguments_ty, pub body: expr_ty, } impl Default for _expr__bindgen_ty_1__bindgen_ty_5 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_6 { pub test: expr_ty, pub body: expr_ty, pub orelse: expr_ty, } impl Default for _expr__bindgen_ty_1__bindgen_ty_6 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_7 { pub keys: *mut asdl_expr_seq, pub values: *mut asdl_expr_seq, } impl Default for _expr__bindgen_ty_1__bindgen_ty_7 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_8 { pub elts: *mut asdl_expr_seq, } impl Default for _expr__bindgen_ty_1__bindgen_ty_8 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_9 { pub elt: expr_ty, pub generators: *mut asdl_comprehension_seq, } impl Default for _expr__bindgen_ty_1__bindgen_ty_9 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_10 { pub elt: expr_ty, pub generators: *mut asdl_comprehension_seq, } impl Default for _expr__bindgen_ty_1__bindgen_ty_10 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_11 { pub key: expr_ty, pub value: expr_ty, pub generators: *mut asdl_comprehension_seq, } impl Default for _expr__bindgen_ty_1__bindgen_ty_11 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_12 { pub elt: expr_ty, pub generators: *mut asdl_comprehension_seq, } impl Default for _expr__bindgen_ty_1__bindgen_ty_12 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_13 { pub value: expr_ty, } impl Default for _expr__bindgen_ty_1__bindgen_ty_13 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_14 { pub value: expr_ty, } impl Default for _expr__bindgen_ty_1__bindgen_ty_14 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_15 { pub value: expr_ty, } impl Default for _expr__bindgen_ty_1__bindgen_ty_15 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_16 { pub left: expr_ty, pub ops: *mut asdl_int_seq, pub comparators: *mut asdl_expr_seq, } impl Default for _expr__bindgen_ty_1__bindgen_ty_16 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_17 { pub func: expr_ty, pub args: *mut asdl_expr_seq, pub keywords: *mut asdl_keyword_seq, } impl Default for _expr__bindgen_ty_1__bindgen_ty_17 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_18 { pub value: expr_ty, pub conversion: ::std::os::raw::c_int, pub format_spec: expr_ty, } impl Default for _expr__bindgen_ty_1__bindgen_ty_18 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_19 { pub values: *mut asdl_expr_seq, } impl Default for _expr__bindgen_ty_1__bindgen_ty_19 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_20 { pub value: constant, pub kind: string, } impl Default for _expr__bindgen_ty_1__bindgen_ty_20 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_21 { pub value: expr_ty, pub attr: identifier, pub ctx: expr_context_ty, } impl Default for _expr__bindgen_ty_1__bindgen_ty_21 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_22 { pub value: expr_ty, pub slice: expr_ty, pub ctx: expr_context_ty, } impl Default for _expr__bindgen_ty_1__bindgen_ty_22 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_23 { pub value: expr_ty, pub ctx: expr_context_ty, } impl Default for _expr__bindgen_ty_1__bindgen_ty_23 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_24 { pub id: identifier, pub ctx: expr_context_ty, } impl Default for _expr__bindgen_ty_1__bindgen_ty_24 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_25 { pub elts: *mut asdl_expr_seq, pub ctx: expr_context_ty, } impl Default for _expr__bindgen_ty_1__bindgen_ty_25 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_26 { pub elts: *mut asdl_expr_seq, pub ctx: expr_context_ty, } impl Default for _expr__bindgen_ty_1__bindgen_ty_26 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_27 { pub lower: expr_ty, pub upper: expr_ty, pub step: expr_ty, } impl Default for _expr__bindgen_ty_1__bindgen_ty_27 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } impl Default for _expr__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } impl Default for _expr { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _comprehension { pub target: expr_ty, pub iter: expr_ty, pub ifs: *mut asdl_expr_seq, pub is_async: ::std::os::raw::c_int, } impl Default for _comprehension { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _arguments { pub posonlyargs: *mut asdl_arg_seq, pub args: *mut asdl_arg_seq, pub vararg: arg_ty, pub kwonlyargs: *mut asdl_arg_seq, pub kw_defaults: *mut asdl_expr_seq, pub kwarg: arg_ty, pub defaults: *mut asdl_expr_seq, } impl Default for _arguments { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _arg { pub arg: identifier, pub annotation: expr_ty, pub type_comment: string, pub lineno: ::std::os::raw::c_int, pub col_offset: ::std::os::raw::c_int, pub end_lineno: ::std::os::raw::c_int, pub end_col_offset: ::std::os::raw::c_int, } impl Default for _arg { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _keyword { pub arg: identifier, pub value: expr_ty, pub lineno: ::std::os::raw::c_int, pub col_offset: ::std::os::raw::c_int, pub end_lineno: ::std::os::raw::c_int, pub end_col_offset: ::std::os::raw::c_int, } impl Default for _keyword { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _parser_runtime_state { pub _not_used: ::std::os::raw::c_int, pub dummy_name: _expr, } impl Default for _parser_runtime_state { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct debug_alloc_api_t { pub api_id: ::std::os::raw::c_char, pub alloc: PyMemAllocatorEx, } impl Default for debug_alloc_api_t { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _pymem_allocators { pub mutex: PyThread_type_lock, pub standard: _pymem_allocators__bindgen_ty_1, pub debug: _pymem_allocators__bindgen_ty_2, pub obj_arena: PyObjectArenaAllocator, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _pymem_allocators__bindgen_ty_1 { pub raw: PyMemAllocatorEx, pub mem: PyMemAllocatorEx, pub obj: PyMemAllocatorEx, } impl Default for _pymem_allocators__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _pymem_allocators__bindgen_ty_2 { pub raw: debug_alloc_api_t, pub mem: debug_alloc_api_t, pub obj: debug_alloc_api_t, } impl Default for _pymem_allocators__bindgen_ty_2 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } impl Default for _pymem_allocators { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct pyhash_runtime_state { pub urandom_cache: pyhash_runtime_state__bindgen_ty_1, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct pyhash_runtime_state__bindgen_ty_1 { pub fd: ::std::os::raw::c_int, pub st_dev: dev_t, pub st_ino: ino_t, } #[repr(C)] #[derive(Copy, Clone)] pub struct _pythread_runtime_state { pub initialized: ::std::os::raw::c_int, pub _condattr_monotonic: _pythread_runtime_state__bindgen_ty_1, } #[repr(C)] #[derive(Copy, Clone)] pub struct _pythread_runtime_state__bindgen_ty_1 { pub ptr: *mut pthread_condattr_t, pub val: pthread_condattr_t, } impl Default for _pythread_runtime_state__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } impl Default for _pythread_runtime_state { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _signals_runtime_state { pub handlers: [_signals_runtime_state__bindgen_ty_1; 65usize], pub wakeup: _signals_runtime_state__bindgen_ty_2, pub is_tripped: _Py_atomic_int, pub default_handler: *mut PyObject, pub ignore_handler: *mut PyObject, pub unhandled_keyboard_interrupt: ::std::os::raw::c_int, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _signals_runtime_state__bindgen_ty_1 { pub tripped: _Py_atomic_int, pub func: _Py_atomic_address, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _signals_runtime_state__bindgen_ty_2 { pub fd: sig_atomic_t, pub warn_on_full_buffer: ::std::os::raw::c_int, } impl Default for _signals_runtime_state { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _PyTraceMalloc_Config { pub initialized: _PyTraceMalloc_Config__bindgen_ty_1, pub tracing: ::std::os::raw::c_int, pub max_nframe: ::std::os::raw::c_int, } pub const _PyTraceMalloc_Config_TRACEMALLOC_NOT_INITIALIZED: _PyTraceMalloc_Config__bindgen_ty_1 = 0; pub const _PyTraceMalloc_Config_TRACEMALLOC_INITIALIZED: _PyTraceMalloc_Config__bindgen_ty_1 = 1; pub const _PyTraceMalloc_Config_TRACEMALLOC_FINALIZED: _PyTraceMalloc_Config__bindgen_ty_1 = 2; pub type _PyTraceMalloc_Config__bindgen_ty_1 = ::std::os::raw::c_uint; impl Default for _PyTraceMalloc_Config { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C, packed)] #[derive(Debug, Copy, Clone)] pub struct tracemalloc_frame { pub filename: *mut PyObject, pub lineno: ::std::os::raw::c_uint, } impl Default for tracemalloc_frame { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct tracemalloc_traceback { pub hash: Py_uhash_t, pub nframe: u16, pub total_nframe: u16, pub frames: [tracemalloc_frame; 1usize], } impl Default for tracemalloc_traceback { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _tracemalloc_runtime_state { pub config: _PyTraceMalloc_Config, pub allocators: _tracemalloc_runtime_state__bindgen_ty_1, pub tables_lock: PyThread_type_lock, pub traced_memory: usize, pub peak_traced_memory: usize, pub filenames: *mut _Py_hashtable_t, pub traceback: *mut tracemalloc_traceback, pub tracebacks: *mut _Py_hashtable_t, pub traces: *mut _Py_hashtable_t, pub domains: *mut _Py_hashtable_t, pub empty_traceback: tracemalloc_traceback, pub reentrant_key: Py_tss_t, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _tracemalloc_runtime_state__bindgen_ty_1 { pub mem: PyMemAllocatorEx, pub raw: PyMemAllocatorEx, pub obj: PyMemAllocatorEx, } impl Default for _tracemalloc_runtime_state__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } impl Default for _tracemalloc_runtime_state { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _getargs_runtime_state { pub mutex: PyThread_type_lock, pub static_parsers: *mut _PyArg_Parser, } impl Default for _getargs_runtime_state { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _gilstate_runtime_state { pub check_enabled: ::std::os::raw::c_int, pub autoInterpreterState: *mut PyInterpreterState, } impl Default for _gilstate_runtime_state { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_AuditHookEntry { pub next: *mut _Py_AuditHookEntry, pub hookCFunction: Py_AuditHookFunction, pub userData: *mut ::std::os::raw::c_void, } impl Default for _Py_AuditHookEntry { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct pyruntimestate { pub _initialized: ::std::os::raw::c_int, pub preinitializing: ::std::os::raw::c_int, pub preinitialized: ::std::os::raw::c_int, pub core_initialized: ::std::os::raw::c_int, pub initialized: ::std::os::raw::c_int, pub _finalizing: _Py_atomic_address, pub interpreters: pyruntimestate_pyinterpreters, pub main_thread: ::std::os::raw::c_ulong, pub xidregistry: pyruntimestate__xidregistry, pub allocators: _pymem_allocators, pub obmalloc: _obmalloc_global_state, pub pyhash_state: pyhash_runtime_state, pub time: _time_runtime_state, pub threads: _pythread_runtime_state, pub signals: _signals_runtime_state, pub autoTSSkey: Py_tss_t, pub trashTSSkey: Py_tss_t, pub orig_argv: PyWideStringList, pub parser: _parser_runtime_state, pub atexit: _atexit_runtime_state, pub imports: _import_runtime_state, pub ceval: _ceval_runtime_state, pub gilstate: _gilstate_runtime_state, pub getargs: _getargs_runtime_state, pub fileutils: _fileutils_state, pub faulthandler: _faulthandler_runtime_state, pub tracemalloc: _tracemalloc_runtime_state, pub preconfig: PyPreConfig, pub open_code_hook: Py_OpenCodeHookFunction, pub open_code_userdata: *mut ::std::os::raw::c_void, pub audit_hooks: pyruntimestate__bindgen_ty_1, pub object_state: _py_object_runtime_state, pub float_state: _Py_float_runtime_state, pub unicode_state: _Py_unicode_runtime_state, pub types: _types_runtime_state, pub static_objects: _Py_static_objects, pub _main_interpreter: PyInterpreterState, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct pyruntimestate_pyinterpreters { pub mutex: PyThread_type_lock, pub head: *mut PyInterpreterState, pub main: *mut PyInterpreterState, pub next_id: i64, } impl Default for pyruntimestate_pyinterpreters { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct pyruntimestate__xidregistry { pub mutex: PyThread_type_lock, pub head: *mut _xidregitem, } impl Default for pyruntimestate__xidregistry { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct pyruntimestate__bindgen_ty_1 { pub mutex: PyThread_type_lock, pub head: *mut _Py_AuditHookEntry, } impl Default for pyruntimestate__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } impl Default for pyruntimestate { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyDictUnicodeEntry { pub me_key: *mut PyObject, pub me_value: *mut PyObject, } impl Default for PyDictUnicodeEntry { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _dictkeysobject { pub dk_refcnt: Py_ssize_t, pub dk_log2_size: u8, pub dk_log2_index_bytes: u8, pub dk_kind: u8, pub dk_version: u32, pub dk_usable: Py_ssize_t, pub dk_nentries: Py_ssize_t, pub dk_indices: [std::os::raw::c_char; 0], } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _dictvalues { pub values: [*mut PyObject; 1usize], } impl Default for _dictvalues { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); unsafe { ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); s.assume_init() } } } ================================================ FILE: src/python_bindings/v3_13_0.rs ================================================ // Generated bindings for python v3.13.0 #![allow(dead_code)] #![allow(non_upper_case_globals)] #![allow(non_camel_case_types)] #![allow(non_snake_case)] #![allow(clippy::useless_transmute)] #![allow(clippy::default_trait_access)] #![allow(clippy::cast_lossless)] #![allow(clippy::trivially_copy_pass_by_ref)] #![allow(clippy::upper_case_acronyms)] #![allow(clippy::too_many_arguments)] /* automatically generated by rust-bindgen */ #[repr(C)] #[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] pub struct __BindgenBitfieldUnit where Storage: AsRef<[u8]> + AsMut<[u8]>, { storage: Storage, align: [Align; 0], } impl __BindgenBitfieldUnit where Storage: AsRef<[u8]> + AsMut<[u8]>, { #[inline] pub fn new(storage: Storage) -> Self { Self { storage, align: [] } } #[inline] pub fn get_bit(&self, index: usize) -> bool { debug_assert!(index / 8 < self.storage.as_ref().len()); let byte_index = index / 8; let byte = self.storage.as_ref()[byte_index]; let bit_index = if cfg!(target_endian = "big") { 7 - (index % 8) } else { index % 8 }; let mask = 1 << bit_index; byte & mask == mask } #[inline] pub fn set_bit(&mut self, index: usize, val: bool) { debug_assert!(index / 8 < self.storage.as_ref().len()); let byte_index = index / 8; let byte = &mut self.storage.as_mut()[byte_index]; let bit_index = if cfg!(target_endian = "big") { 7 - (index % 8) } else { index % 8 }; let mask = 1 << bit_index; if val { *byte |= mask; } else { *byte &= !mask; } } #[inline] pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); let mut val = 0; for i in 0..(bit_width as usize) { if self.get_bit(i + bit_offset) { let index = if cfg!(target_endian = "big") { bit_width as usize - 1 - i } else { i }; val |= 1 << index; } } val } #[inline] pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); for i in 0..(bit_width as usize) { let mask = 1 << i; let val_bit_is_set = val & mask == mask; let index = if cfg!(target_endian = "big") { bit_width as usize - 1 - i } else { i }; self.set_bit(index + bit_offset, val_bit_is_set); } } } #[repr(C)] #[derive(Default)] pub struct __IncompleteArrayField(::std::marker::PhantomData, [T; 0]); impl __IncompleteArrayField { #[inline] pub fn new() -> Self { __IncompleteArrayField(::std::marker::PhantomData, []) } #[inline] pub unsafe fn as_ptr(&self) -> *const T { ::std::mem::transmute(self) } #[inline] pub unsafe fn as_mut_ptr(&mut self) -> *mut T { ::std::mem::transmute(self) } #[inline] pub unsafe fn as_slice(&self, len: usize) -> &[T] { ::std::slice::from_raw_parts(self.as_ptr(), len) } #[inline] pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] { ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len) } } impl ::std::fmt::Debug for __IncompleteArrayField { fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { fmt.write_str("__IncompleteArrayField") } } impl ::std::clone::Clone for __IncompleteArrayField { #[inline] fn clone(&self) -> Self { Self::new() } } pub type __int8_t = ::std::os::raw::c_schar; pub type __uint8_t = ::std::os::raw::c_uchar; pub type __uint16_t = ::std::os::raw::c_ushort; pub type __int32_t = ::std::os::raw::c_int; pub type __uint32_t = ::std::os::raw::c_uint; pub type __int64_t = ::std::os::raw::c_long; pub type __uint64_t = ::std::os::raw::c_ulong; pub type __dev_t = ::std::os::raw::c_ulong; pub type __uid_t = ::std::os::raw::c_uint; pub type __ino64_t = ::std::os::raw::c_ulong; pub type __pid_t = ::std::os::raw::c_int; pub type __clock_t = ::std::os::raw::c_long; pub type __ssize_t = ::std::os::raw::c_long; pub type __sig_atomic_t = ::std::os::raw::c_int; pub type wchar_t = ::std::os::raw::c_int; pub type ino_t = __ino64_t; pub type dev_t = __dev_t; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct __sigset_t { pub __val: [::std::os::raw::c_ulong; 16usize], } #[repr(C)] #[derive(Copy, Clone)] pub union __atomic_wide_counter { pub __value64: ::std::os::raw::c_ulonglong, pub __value32: __atomic_wide_counter__bindgen_ty_1, _bindgen_union_align: u64, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct __atomic_wide_counter__bindgen_ty_1 { pub __low: ::std::os::raw::c_uint, pub __high: ::std::os::raw::c_uint, } impl Default for __atomic_wide_counter { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct __pthread_internal_list { pub __prev: *mut __pthread_internal_list, pub __next: *mut __pthread_internal_list, } impl Default for __pthread_internal_list { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __pthread_list_t = __pthread_internal_list; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct __pthread_mutex_s { pub __lock: ::std::os::raw::c_int, pub __count: ::std::os::raw::c_uint, pub __owner: ::std::os::raw::c_int, pub __nusers: ::std::os::raw::c_uint, pub __kind: ::std::os::raw::c_int, pub __spins: ::std::os::raw::c_short, pub __elision: ::std::os::raw::c_short, pub __list: __pthread_list_t, } impl Default for __pthread_mutex_s { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct __pthread_cond_s { pub __wseq: __atomic_wide_counter, pub __g1_start: __atomic_wide_counter, pub __g_refs: [::std::os::raw::c_uint; 2usize], pub __g_size: [::std::os::raw::c_uint; 2usize], pub __g1_orig_size: ::std::os::raw::c_uint, pub __wrefs: ::std::os::raw::c_uint, pub __g_signals: [::std::os::raw::c_uint; 2usize], } impl Default for __pthread_cond_s { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub union pthread_condattr_t { pub __size: [::std::os::raw::c_char; 4usize], pub __align: ::std::os::raw::c_int, _bindgen_union_align: u32, } impl Default for pthread_condattr_t { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type pthread_key_t = ::std::os::raw::c_uint; #[repr(C)] #[derive(Copy, Clone)] pub union pthread_mutex_t { pub __data: __pthread_mutex_s, pub __size: [::std::os::raw::c_char; 40usize], pub __align: ::std::os::raw::c_long, _bindgen_union_align: [u64; 5usize], } impl Default for pthread_mutex_t { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub union pthread_cond_t { pub __data: __pthread_cond_s, pub __size: [::std::os::raw::c_char; 48usize], pub __align: ::std::os::raw::c_longlong, _bindgen_union_align: [u64; 6usize], } impl Default for pthread_cond_t { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type Py_ssize_t = isize; pub type Py_hash_t = Py_ssize_t; pub type Py_uhash_t = usize; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyMemAllocatorEx { pub ctx: *mut ::std::os::raw::c_void, pub malloc: ::std::option::Option< unsafe extern "C" fn( ctx: *mut ::std::os::raw::c_void, size: usize, ) -> *mut ::std::os::raw::c_void, >, pub calloc: ::std::option::Option< unsafe extern "C" fn( ctx: *mut ::std::os::raw::c_void, nelem: usize, elsize: usize, ) -> *mut ::std::os::raw::c_void, >, pub realloc: ::std::option::Option< unsafe extern "C" fn( ctx: *mut ::std::os::raw::c_void, ptr: *mut ::std::os::raw::c_void, new_size: usize, ) -> *mut ::std::os::raw::c_void, >, pub free: ::std::option::Option< unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, ptr: *mut ::std::os::raw::c_void), >, } impl Default for PyMemAllocatorEx { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyObject = _object; pub type PyLongObject = _longobject; pub type PyTypeObject = _typeobject; pub type PyFrameObject = _frame; pub type PyThreadState = _ts; pub type PyInterpreterState = _is; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct Py_buffer { pub buf: *mut ::std::os::raw::c_void, pub obj: *mut PyObject, pub len: Py_ssize_t, pub itemsize: Py_ssize_t, pub readonly: ::std::os::raw::c_int, pub ndim: ::std::os::raw::c_int, pub format: *mut ::std::os::raw::c_char, pub shape: *mut Py_ssize_t, pub strides: *mut Py_ssize_t, pub suboffsets: *mut Py_ssize_t, pub internal: *mut ::std::os::raw::c_void, } impl Default for Py_buffer { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type getbufferproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut Py_buffer, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >; pub type releasebufferproc = ::std::option::Option; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct PyMutex { pub _bits: u8, } #[repr(C)] #[derive(Copy, Clone)] pub struct _object { pub __bindgen_anon_1: _object__bindgen_ty_1, pub ob_type: *mut PyTypeObject, } #[repr(C)] #[derive(Copy, Clone)] pub union _object__bindgen_ty_1 { pub ob_refcnt: Py_ssize_t, // line manually added, see https://github.com/benfred/py-spy/issues/753 #[cfg(target_pointer_width = "64")] pub ob_refcnt_split: [u32; 2usize], // line manually added, see https://github.com/benfred/py-spy/issues/753 #[cfg(target_pointer_width = "64")] _bindgen_union_align: u64, } impl Default for _object__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for _object { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct PyVarObject { pub ob_base: PyObject, pub ob_size: Py_ssize_t, } impl Default for PyVarObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type unaryfunc = ::std::option::Option *mut PyObject>; pub type binaryfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject, >; pub type ternaryfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> *mut PyObject, >; pub type inquiry = ::std::option::Option ::std::os::raw::c_int>; pub type lenfunc = ::std::option::Option Py_ssize_t>; pub type ssizeargfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: Py_ssize_t) -> *mut PyObject, >; pub type ssizeobjargproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: Py_ssize_t, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type objobjargproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type objobjproc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> ::std::os::raw::c_int, >; pub type visitproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; pub type traverseproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: visitproc, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; pub type freefunc = ::std::option::Option; pub type destructor = ::std::option::Option; pub type getattrfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_char) -> *mut PyObject, >; pub type getattrofunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject, >; pub type setattrfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_char, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type setattrofunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type reprfunc = ::std::option::Option *mut PyObject>; pub type hashfunc = ::std::option::Option Py_hash_t>; pub type richcmpfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: ::std::os::raw::c_int, ) -> *mut PyObject, >; pub type getiterfunc = ::std::option::Option *mut PyObject>; pub type iternextfunc = ::std::option::Option *mut PyObject>; pub type descrgetfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> *mut PyObject, >; pub type descrsetfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type initproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type newfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyTypeObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> *mut PyObject, >; pub type allocfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyTypeObject, arg2: Py_ssize_t) -> *mut PyObject, >; pub type vectorcallfunc = ::std::option::Option< unsafe extern "C" fn( callable: *mut PyObject, args: *const *mut PyObject, nargsf: usize, kwnames: *mut PyObject, ) -> *mut PyObject, >; pub const PySendResult_PYGEN_RETURN: PySendResult = 0; pub const PySendResult_PYGEN_ERROR: PySendResult = -1; pub const PySendResult_PYGEN_NEXT: PySendResult = 1; pub type PySendResult = i32; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyNumberMethods { pub nb_add: binaryfunc, pub nb_subtract: binaryfunc, pub nb_multiply: binaryfunc, pub nb_remainder: binaryfunc, pub nb_divmod: binaryfunc, pub nb_power: ternaryfunc, pub nb_negative: unaryfunc, pub nb_positive: unaryfunc, pub nb_absolute: unaryfunc, pub nb_bool: inquiry, pub nb_invert: unaryfunc, pub nb_lshift: binaryfunc, pub nb_rshift: binaryfunc, pub nb_and: binaryfunc, pub nb_xor: binaryfunc, pub nb_or: binaryfunc, pub nb_int: unaryfunc, pub nb_reserved: *mut ::std::os::raw::c_void, pub nb_float: unaryfunc, pub nb_inplace_add: binaryfunc, pub nb_inplace_subtract: binaryfunc, pub nb_inplace_multiply: binaryfunc, pub nb_inplace_remainder: binaryfunc, pub nb_inplace_power: ternaryfunc, pub nb_inplace_lshift: binaryfunc, pub nb_inplace_rshift: binaryfunc, pub nb_inplace_and: binaryfunc, pub nb_inplace_xor: binaryfunc, pub nb_inplace_or: binaryfunc, pub nb_floor_divide: binaryfunc, pub nb_true_divide: binaryfunc, pub nb_inplace_floor_divide: binaryfunc, pub nb_inplace_true_divide: binaryfunc, pub nb_index: unaryfunc, pub nb_matrix_multiply: binaryfunc, pub nb_inplace_matrix_multiply: binaryfunc, } impl Default for PyNumberMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PySequenceMethods { pub sq_length: lenfunc, pub sq_concat: binaryfunc, pub sq_repeat: ssizeargfunc, pub sq_item: ssizeargfunc, pub was_sq_slice: *mut ::std::os::raw::c_void, pub sq_ass_item: ssizeobjargproc, pub was_sq_ass_slice: *mut ::std::os::raw::c_void, pub sq_contains: objobjproc, pub sq_inplace_concat: binaryfunc, pub sq_inplace_repeat: ssizeargfunc, } impl Default for PySequenceMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyMappingMethods { pub mp_length: lenfunc, pub mp_subscript: binaryfunc, pub mp_ass_subscript: objobjargproc, } impl Default for PyMappingMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type sendfunc = ::std::option::Option< unsafe extern "C" fn( iter: *mut PyObject, value: *mut PyObject, result: *mut *mut PyObject, ) -> PySendResult, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyAsyncMethods { pub am_await: unaryfunc, pub am_aiter: unaryfunc, pub am_anext: unaryfunc, pub am_send: sendfunc, } impl Default for PyAsyncMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyBufferProcs { pub bf_getbuffer: getbufferproc, pub bf_releasebuffer: releasebufferproc, } impl Default for PyBufferProcs { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _typeobject { pub ob_base: PyVarObject, pub tp_name: *const ::std::os::raw::c_char, pub tp_basicsize: Py_ssize_t, pub tp_itemsize: Py_ssize_t, pub tp_dealloc: destructor, pub tp_vectorcall_offset: Py_ssize_t, pub tp_getattr: getattrfunc, pub tp_setattr: setattrfunc, pub tp_as_async: *mut PyAsyncMethods, pub tp_repr: reprfunc, pub tp_as_number: *mut PyNumberMethods, pub tp_as_sequence: *mut PySequenceMethods, pub tp_as_mapping: *mut PyMappingMethods, pub tp_hash: hashfunc, pub tp_call: ternaryfunc, pub tp_str: reprfunc, pub tp_getattro: getattrofunc, pub tp_setattro: setattrofunc, pub tp_as_buffer: *mut PyBufferProcs, pub tp_flags: ::std::os::raw::c_ulong, pub tp_doc: *const ::std::os::raw::c_char, pub tp_traverse: traverseproc, pub tp_clear: inquiry, pub tp_richcompare: richcmpfunc, pub tp_weaklistoffset: Py_ssize_t, pub tp_iter: getiterfunc, pub tp_iternext: iternextfunc, pub tp_methods: *mut PyMethodDef, pub tp_members: *mut PyMemberDef, pub tp_getset: *mut PyGetSetDef, pub tp_base: *mut PyTypeObject, pub tp_dict: *mut PyObject, pub tp_descr_get: descrgetfunc, pub tp_descr_set: descrsetfunc, pub tp_dictoffset: Py_ssize_t, pub tp_init: initproc, pub tp_alloc: allocfunc, pub tp_new: newfunc, pub tp_free: freefunc, pub tp_is_gc: inquiry, pub tp_bases: *mut PyObject, pub tp_mro: *mut PyObject, pub tp_cache: *mut PyObject, pub tp_subclasses: *mut ::std::os::raw::c_void, pub tp_weaklist: *mut PyObject, pub tp_del: destructor, pub tp_version_tag: ::std::os::raw::c_uint, pub tp_finalize: destructor, pub tp_vectorcall: vectorcallfunc, pub tp_watched: ::std::os::raw::c_uchar, pub tp_versions_used: u16, } impl Default for _typeobject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _specialization_cache { pub getitem: *mut PyObject, pub getitem_version: u32, pub init: *mut PyObject, } impl Default for _specialization_cache { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _heaptypeobject { pub ht_type: PyTypeObject, pub as_async: PyAsyncMethods, pub as_number: PyNumberMethods, pub as_mapping: PyMappingMethods, pub as_sequence: PySequenceMethods, pub as_buffer: PyBufferProcs, pub ht_name: *mut PyObject, pub ht_slots: *mut PyObject, pub ht_qualname: *mut PyObject, pub ht_cached_keys: *mut _dictkeysobject, pub ht_module: *mut PyObject, pub _ht_tpname: *mut ::std::os::raw::c_char, pub _spec_cache: _specialization_cache, } impl Default for _heaptypeobject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyHeapTypeObject = _heaptypeobject; pub type PyType_WatchCallback = ::std::option::Option ::std::os::raw::c_int>; pub const PyRefTracerEvent_PyRefTracer_CREATE: PyRefTracerEvent = 0; pub const PyRefTracerEvent_PyRefTracer_DESTROY: PyRefTracerEvent = 1; pub type PyRefTracerEvent = u32; pub type PyRefTracer = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, event: PyRefTracerEvent, arg2: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyObjectArenaAllocator { pub ctx: *mut ::std::os::raw::c_void, pub alloc: ::std::option::Option< unsafe extern "C" fn( ctx: *mut ::std::os::raw::c_void, size: usize, ) -> *mut ::std::os::raw::c_void, >, pub free: ::std::option::Option< unsafe extern "C" fn( ctx: *mut ::std::os::raw::c_void, ptr: *mut ::std::os::raw::c_void, size: usize, ), >, } impl Default for PyObjectArenaAllocator { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct PyBytesObject { pub ob_base: PyVarObject, pub ob_shash: Py_hash_t, pub ob_sval: [::std::os::raw::c_char; 1usize], } impl Default for PyBytesObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type Py_UCS4 = u32; pub type Py_UCS2 = u16; pub type Py_UCS1 = u8; #[repr(C)] #[derive(Copy, Clone)] pub struct PyASCIIObject { pub ob_base: PyObject, pub length: Py_ssize_t, pub hash: Py_hash_t, pub state: PyASCIIObject__bindgen_ty_1, } #[repr(C)] #[repr(align(4))] #[derive(Debug, Default, Copy, Clone)] pub struct PyASCIIObject__bindgen_ty_1 { pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u8>, } impl PyASCIIObject__bindgen_ty_1 { #[inline] pub fn interned(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) } } #[inline] pub fn set_interned(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(0usize, 2u8, val as u64) } } #[inline] pub fn kind(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 3u8) as u32) } } #[inline] pub fn set_kind(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(2usize, 3u8, val as u64) } } #[inline] pub fn compact(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } } #[inline] pub fn set_compact(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(5usize, 1u8, val as u64) } } #[inline] pub fn ascii(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } } #[inline] pub fn set_ascii(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(6usize, 1u8, val as u64) } } #[inline] pub fn statically_allocated(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } } #[inline] pub fn set_statically_allocated(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(7usize, 1u8, val as u64) } } #[inline] pub fn new_bitfield_1( interned: ::std::os::raw::c_uint, kind: ::std::os::raw::c_uint, compact: ::std::os::raw::c_uint, ascii: ::std::os::raw::c_uint, statically_allocated: ::std::os::raw::c_uint, ) -> __BindgenBitfieldUnit<[u8; 4usize], u8> { let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u8> = Default::default(); __bindgen_bitfield_unit.set(0usize, 2u8, { let interned: u32 = unsafe { ::std::mem::transmute(interned) }; interned as u64 }); __bindgen_bitfield_unit.set(2usize, 3u8, { let kind: u32 = unsafe { ::std::mem::transmute(kind) }; kind as u64 }); __bindgen_bitfield_unit.set(5usize, 1u8, { let compact: u32 = unsafe { ::std::mem::transmute(compact) }; compact as u64 }); __bindgen_bitfield_unit.set(6usize, 1u8, { let ascii: u32 = unsafe { ::std::mem::transmute(ascii) }; ascii as u64 }); __bindgen_bitfield_unit.set(7usize, 1u8, { let statically_allocated: u32 = unsafe { ::std::mem::transmute(statically_allocated) }; statically_allocated as u64 }); __bindgen_bitfield_unit } } impl Default for PyASCIIObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct PyCompactUnicodeObject { pub _base: PyASCIIObject, pub utf8_length: Py_ssize_t, pub utf8: *mut ::std::os::raw::c_char, } impl Default for PyCompactUnicodeObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct PyUnicodeObject { pub _base: PyCompactUnicodeObject, pub data: PyUnicodeObject__bindgen_ty_1, } #[repr(C)] #[derive(Copy, Clone)] pub union PyUnicodeObject__bindgen_ty_1 { pub any: *mut ::std::os::raw::c_void, pub latin1: *mut Py_UCS1, pub ucs2: *mut Py_UCS2, pub ucs4: *mut Py_UCS4, _bindgen_union_align: u64, } impl Default for PyUnicodeObject__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for PyUnicodeObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct PyBaseExceptionObject { pub ob_base: PyObject, pub dict: *mut PyObject, pub args: *mut PyObject, pub notes: *mut PyObject, pub traceback: *mut PyObject, pub context: *mut PyObject, pub cause: *mut PyObject, pub suppress_context: ::std::os::raw::c_char, } impl Default for PyBaseExceptionObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type digit = u32; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _PyLongValue { pub lv_tag: usize, pub ob_digit: [digit; 1usize], } #[repr(C)] #[derive(Copy, Clone)] pub struct _longobject { pub ob_base: PyObject, pub long_value: _PyLongValue, } impl Default for _longobject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct PyFloatObject { pub ob_base: PyObject, pub ob_fval: f64, } impl Default for PyFloatObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct PyTupleObject { pub ob_base: PyVarObject, pub ob_item: [*mut PyObject; 1usize], } impl Default for PyTupleObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct PyListObject { pub ob_base: PyVarObject, pub ob_item: *mut *mut PyObject, pub allocated: Py_ssize_t, } impl Default for PyListObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyDictKeysObject = _dictkeysobject; pub type PyDictValues = _dictvalues; #[repr(C)] #[derive(Copy, Clone)] pub struct PyDictObject { pub ob_base: PyObject, pub ma_used: Py_ssize_t, pub ma_version_tag: u64, pub ma_keys: *mut PyDictKeysObject, pub ma_values: *mut PyDictValues, } impl Default for PyDictObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub const PyDict_WatchEvent_PyDict_EVENT_ADDED: PyDict_WatchEvent = 0; pub const PyDict_WatchEvent_PyDict_EVENT_MODIFIED: PyDict_WatchEvent = 1; pub const PyDict_WatchEvent_PyDict_EVENT_DELETED: PyDict_WatchEvent = 2; pub const PyDict_WatchEvent_PyDict_EVENT_CLONED: PyDict_WatchEvent = 3; pub const PyDict_WatchEvent_PyDict_EVENT_CLEARED: PyDict_WatchEvent = 4; pub const PyDict_WatchEvent_PyDict_EVENT_DEALLOCATED: PyDict_WatchEvent = 5; pub type PyDict_WatchEvent = u32; pub type PyDict_WatchCallback = ::std::option::Option< unsafe extern "C" fn( event: PyDict_WatchEvent, dict: *mut PyObject, key: *mut PyObject, new_value: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type PyCFunction = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyMethodDef { pub ml_name: *const ::std::os::raw::c_char, pub ml_meth: PyCFunction, pub ml_flags: ::std::os::raw::c_int, pub ml_doc: *const ::std::os::raw::c_char, } impl Default for PyMethodDef { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct PyFunctionObject { pub ob_base: PyObject, pub func_globals: *mut PyObject, pub func_builtins: *mut PyObject, pub func_name: *mut PyObject, pub func_qualname: *mut PyObject, pub func_code: *mut PyObject, pub func_defaults: *mut PyObject, pub func_kwdefaults: *mut PyObject, pub func_closure: *mut PyObject, pub func_doc: *mut PyObject, pub func_dict: *mut PyObject, pub func_weakreflist: *mut PyObject, pub func_module: *mut PyObject, pub func_annotations: *mut PyObject, pub func_typeparams: *mut PyObject, pub vectorcall: vectorcallfunc, pub func_version: u32, } impl Default for PyFunctionObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub const PyFunction_WatchEvent_PyFunction_EVENT_CREATE: PyFunction_WatchEvent = 0; pub const PyFunction_WatchEvent_PyFunction_EVENT_DESTROY: PyFunction_WatchEvent = 1; pub const PyFunction_WatchEvent_PyFunction_EVENT_MODIFY_CODE: PyFunction_WatchEvent = 2; pub const PyFunction_WatchEvent_PyFunction_EVENT_MODIFY_DEFAULTS: PyFunction_WatchEvent = 3; pub const PyFunction_WatchEvent_PyFunction_EVENT_MODIFY_KWDEFAULTS: PyFunction_WatchEvent = 4; pub type PyFunction_WatchEvent = u32; pub type PyFunction_WatchCallback = ::std::option::Option< unsafe extern "C" fn( event: PyFunction_WatchEvent, func: *mut PyFunctionObject, new_value: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type Py_OpenCodeHookFunction = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_void) -> *mut PyObject, >; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_LocalMonitors { pub tools: [u8; 10usize], } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_GlobalMonitors { pub tools: [u8; 15usize], } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _PyCoCached { pub _co_code: *mut PyObject, pub _co_varnames: *mut PyObject, pub _co_cellvars: *mut PyObject, pub _co_freevars: *mut PyObject, } impl Default for _PyCoCached { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _PyCoLineInstrumentationData { pub original_opcode: u8, pub line_delta: i8, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _PyExecutorArray { pub size: ::std::os::raw::c_int, pub capacity: ::std::os::raw::c_int, pub executors: [*mut _PyExecutorObject; 1usize], } impl Default for _PyExecutorArray { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _PyCoMonitoringData { pub local_monitors: _Py_LocalMonitors, pub active_monitors: _Py_LocalMonitors, pub tools: *mut u8, pub lines: *mut _PyCoLineInstrumentationData, pub line_tools: *mut u8, pub per_instruction_opcodes: *mut u8, pub per_instruction_tools: *mut u8, } impl Default for _PyCoMonitoringData { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct PyCodeObject { pub ob_base: PyVarObject, pub co_consts: *mut PyObject, pub co_names: *mut PyObject, pub co_exceptiontable: *mut PyObject, pub co_flags: ::std::os::raw::c_int, pub co_argcount: ::std::os::raw::c_int, pub co_posonlyargcount: ::std::os::raw::c_int, pub co_kwonlyargcount: ::std::os::raw::c_int, pub co_stacksize: ::std::os::raw::c_int, pub co_firstlineno: ::std::os::raw::c_int, pub co_nlocalsplus: ::std::os::raw::c_int, pub co_framesize: ::std::os::raw::c_int, pub co_nlocals: ::std::os::raw::c_int, pub co_ncellvars: ::std::os::raw::c_int, pub co_nfreevars: ::std::os::raw::c_int, pub co_version: u32, pub co_localsplusnames: *mut PyObject, pub co_localspluskinds: *mut PyObject, pub co_filename: *mut PyObject, pub co_name: *mut PyObject, pub co_qualname: *mut PyObject, pub co_linetable: *mut PyObject, pub co_weakreflist: *mut PyObject, pub co_executors: *mut _PyExecutorArray, pub _co_cached: *mut _PyCoCached, pub _co_instrumentation_version: usize, pub _co_monitoring: *mut _PyCoMonitoringData, pub _co_firsttraceable: ::std::os::raw::c_int, pub co_extra: *mut ::std::os::raw::c_void, pub co_code_adaptive: [::std::os::raw::c_char; 1usize], } impl Default for PyCodeObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub const PyCodeEvent_PY_CODE_EVENT_CREATE: PyCodeEvent = 0; pub const PyCodeEvent_PY_CODE_EVENT_DESTROY: PyCodeEvent = 1; pub type PyCodeEvent = u32; pub type PyCode_WatchCallback = ::std::option::Option< unsafe extern "C" fn(event: PyCodeEvent, co: *mut PyCodeObject) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Copy, Clone)] pub struct PySliceObject { pub ob_base: PyObject, pub start: *mut PyObject, pub stop: *mut PyObject, pub step: *mut PyObject, } impl Default for PySliceObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyWideStringList { pub length: Py_ssize_t, pub items: *mut *mut wchar_t, } impl Default for PyWideStringList { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct PyPreConfig { pub _config_init: ::std::os::raw::c_int, pub parse_argv: ::std::os::raw::c_int, pub isolated: ::std::os::raw::c_int, pub use_environment: ::std::os::raw::c_int, pub configure_locale: ::std::os::raw::c_int, pub coerce_c_locale: ::std::os::raw::c_int, pub coerce_c_locale_warn: ::std::os::raw::c_int, pub utf8_mode: ::std::os::raw::c_int, pub dev_mode: ::std::os::raw::c_int, pub allocator: ::std::os::raw::c_int, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyConfig { pub _config_init: ::std::os::raw::c_int, pub isolated: ::std::os::raw::c_int, pub use_environment: ::std::os::raw::c_int, pub dev_mode: ::std::os::raw::c_int, pub install_signal_handlers: ::std::os::raw::c_int, pub use_hash_seed: ::std::os::raw::c_int, pub hash_seed: ::std::os::raw::c_ulong, pub faulthandler: ::std::os::raw::c_int, pub tracemalloc: ::std::os::raw::c_int, pub perf_profiling: ::std::os::raw::c_int, pub import_time: ::std::os::raw::c_int, pub code_debug_ranges: ::std::os::raw::c_int, pub show_ref_count: ::std::os::raw::c_int, pub dump_refs: ::std::os::raw::c_int, pub dump_refs_file: *mut wchar_t, pub malloc_stats: ::std::os::raw::c_int, pub filesystem_encoding: *mut wchar_t, pub filesystem_errors: *mut wchar_t, pub pycache_prefix: *mut wchar_t, pub parse_argv: ::std::os::raw::c_int, pub orig_argv: PyWideStringList, pub argv: PyWideStringList, pub xoptions: PyWideStringList, pub warnoptions: PyWideStringList, pub site_import: ::std::os::raw::c_int, pub bytes_warning: ::std::os::raw::c_int, pub warn_default_encoding: ::std::os::raw::c_int, pub inspect: ::std::os::raw::c_int, pub interactive: ::std::os::raw::c_int, pub optimization_level: ::std::os::raw::c_int, pub parser_debug: ::std::os::raw::c_int, pub write_bytecode: ::std::os::raw::c_int, pub verbose: ::std::os::raw::c_int, pub quiet: ::std::os::raw::c_int, pub user_site_directory: ::std::os::raw::c_int, pub configure_c_stdio: ::std::os::raw::c_int, pub buffered_stdio: ::std::os::raw::c_int, pub stdio_encoding: *mut wchar_t, pub stdio_errors: *mut wchar_t, pub check_hash_pycs_mode: *mut wchar_t, pub use_frozen_modules: ::std::os::raw::c_int, pub safe_path: ::std::os::raw::c_int, pub int_max_str_digits: ::std::os::raw::c_int, pub cpu_count: ::std::os::raw::c_int, pub pathconfig_warnings: ::std::os::raw::c_int, pub program_name: *mut wchar_t, pub pythonpath_env: *mut wchar_t, pub home: *mut wchar_t, pub platlibdir: *mut wchar_t, pub module_search_paths_set: ::std::os::raw::c_int, pub module_search_paths: PyWideStringList, pub stdlib_dir: *mut wchar_t, pub executable: *mut wchar_t, pub base_executable: *mut wchar_t, pub prefix: *mut wchar_t, pub base_prefix: *mut wchar_t, pub exec_prefix: *mut wchar_t, pub base_exec_prefix: *mut wchar_t, pub skip_source_first_line: ::std::os::raw::c_int, pub run_command: *mut wchar_t, pub run_module: *mut wchar_t, pub run_filename: *mut wchar_t, pub sys_path_0: *mut wchar_t, pub _install_importlib: ::std::os::raw::c_int, pub _init_main: ::std::os::raw::c_int, pub _is_python_build: ::std::os::raw::c_int, } impl Default for PyConfig { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type Py_tracefunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyFrameObject, arg3: ::std::os::raw::c_int, arg4: *mut PyObject, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _err_stackitem { pub exc_value: *mut PyObject, pub previous_item: *mut _err_stackitem, } impl Default for _err_stackitem { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type _PyErr_StackItem = _err_stackitem; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _stack_chunk { pub previous: *mut _stack_chunk, pub size: usize, pub top: usize, pub data: [*mut PyObject; 1usize], } impl Default for _stack_chunk { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type _PyStackChunk = _stack_chunk; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _ts { pub prev: *mut PyThreadState, pub next: *mut PyThreadState, pub interp: *mut PyInterpreterState, pub eval_breaker: usize, pub _status: _ts__bindgen_ty_1, pub _whence: ::std::os::raw::c_int, pub state: ::std::os::raw::c_int, pub py_recursion_remaining: ::std::os::raw::c_int, pub py_recursion_limit: ::std::os::raw::c_int, pub c_recursion_remaining: ::std::os::raw::c_int, pub recursion_headroom: ::std::os::raw::c_int, pub tracing: ::std::os::raw::c_int, pub what_event: ::std::os::raw::c_int, pub current_frame: *mut _PyInterpreterFrame, pub c_profilefunc: Py_tracefunc, pub c_tracefunc: Py_tracefunc, pub c_profileobj: *mut PyObject, pub c_traceobj: *mut PyObject, pub current_exception: *mut PyObject, pub exc_info: *mut _PyErr_StackItem, pub dict: *mut PyObject, pub gilstate_counter: ::std::os::raw::c_int, pub async_exc: *mut PyObject, pub thread_id: ::std::os::raw::c_ulong, pub native_thread_id: ::std::os::raw::c_ulong, pub delete_later: *mut PyObject, pub critical_section: usize, pub coroutine_origin_tracking_depth: ::std::os::raw::c_int, pub async_gen_firstiter: *mut PyObject, pub async_gen_finalizer: *mut PyObject, pub context: *mut PyObject, pub context_ver: u64, pub id: u64, pub datastack_chunk: *mut _PyStackChunk, pub datastack_top: *mut *mut PyObject, pub datastack_limit: *mut *mut PyObject, pub exc_state: _PyErr_StackItem, pub previous_executor: *mut PyObject, pub dict_global_version: u64, pub threading_local_key: *mut PyObject, pub threading_local_sentinel: *mut PyObject, } #[repr(C)] #[repr(align(4))] #[derive(Debug, Default, Copy, Clone)] pub struct _ts__bindgen_ty_1 { pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u8>, } impl _ts__bindgen_ty_1 { #[inline] pub fn initialized(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } } #[inline] pub fn set_initialized(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(0usize, 1u8, val as u64) } } #[inline] pub fn bound(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } } #[inline] pub fn set_bound(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(1usize, 1u8, val as u64) } } #[inline] pub fn unbound(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } } #[inline] pub fn set_unbound(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(2usize, 1u8, val as u64) } } #[inline] pub fn bound_gilstate(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } } #[inline] pub fn set_bound_gilstate(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(3usize, 1u8, val as u64) } } #[inline] pub fn active(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } } #[inline] pub fn set_active(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(4usize, 1u8, val as u64) } } #[inline] pub fn holds_gil(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } } #[inline] pub fn set_holds_gil(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(5usize, 1u8, val as u64) } } #[inline] pub fn finalizing(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } } #[inline] pub fn set_finalizing(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(6usize, 1u8, val as u64) } } #[inline] pub fn cleared(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } } #[inline] pub fn set_cleared(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(7usize, 1u8, val as u64) } } #[inline] pub fn finalized(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } } #[inline] pub fn set_finalized(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(8usize, 1u8, val as u64) } } #[inline] pub fn new_bitfield_1( initialized: ::std::os::raw::c_uint, bound: ::std::os::raw::c_uint, unbound: ::std::os::raw::c_uint, bound_gilstate: ::std::os::raw::c_uint, active: ::std::os::raw::c_uint, holds_gil: ::std::os::raw::c_uint, finalizing: ::std::os::raw::c_uint, cleared: ::std::os::raw::c_uint, finalized: ::std::os::raw::c_uint, ) -> __BindgenBitfieldUnit<[u8; 4usize], u8> { let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u8> = Default::default(); __bindgen_bitfield_unit.set(0usize, 1u8, { let initialized: u32 = unsafe { ::std::mem::transmute(initialized) }; initialized as u64 }); __bindgen_bitfield_unit.set(1usize, 1u8, { let bound: u32 = unsafe { ::std::mem::transmute(bound) }; bound as u64 }); __bindgen_bitfield_unit.set(2usize, 1u8, { let unbound: u32 = unsafe { ::std::mem::transmute(unbound) }; unbound as u64 }); __bindgen_bitfield_unit.set(3usize, 1u8, { let bound_gilstate: u32 = unsafe { ::std::mem::transmute(bound_gilstate) }; bound_gilstate as u64 }); __bindgen_bitfield_unit.set(4usize, 1u8, { let active: u32 = unsafe { ::std::mem::transmute(active) }; active as u64 }); __bindgen_bitfield_unit.set(5usize, 1u8, { let holds_gil: u32 = unsafe { ::std::mem::transmute(holds_gil) }; holds_gil as u64 }); __bindgen_bitfield_unit.set(6usize, 1u8, { let finalizing: u32 = unsafe { ::std::mem::transmute(finalizing) }; finalizing as u64 }); __bindgen_bitfield_unit.set(7usize, 1u8, { let cleared: u32 = unsafe { ::std::mem::transmute(cleared) }; cleared as u64 }); __bindgen_bitfield_unit.set(8usize, 1u8, { let finalized: u32 = unsafe { ::std::mem::transmute(finalized) }; finalized as u64 }); __bindgen_bitfield_unit } } impl Default for _ts { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type _PyFrameEvalFunction = ::std::option::Option< unsafe extern "C" fn( tstate: *mut PyThreadState, arg1: *mut _PyInterpreterFrame, arg2: ::std::os::raw::c_int, ) -> *mut PyObject, >; pub type getter = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_void) -> *mut PyObject, >; pub type setter = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyGetSetDef { pub name: *const ::std::os::raw::c_char, pub get: getter, pub set: setter, pub doc: *const ::std::os::raw::c_char, pub closure: *mut ::std::os::raw::c_void, } impl Default for PyGetSetDef { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyMemberDef { pub name: *const ::std::os::raw::c_char, pub type_: ::std::os::raw::c_int, pub offset: Py_ssize_t, pub flags: ::std::os::raw::c_int, pub doc: *const ::std::os::raw::c_char, } impl Default for PyMemberDef { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type wrapperfunc = ::std::option::Option< unsafe extern "C" fn( self_: *mut PyObject, args: *mut PyObject, wrapped: *mut ::std::os::raw::c_void, ) -> *mut PyObject, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct wrapperbase { pub name: *const ::std::os::raw::c_char, pub offset: ::std::os::raw::c_int, pub function: *mut ::std::os::raw::c_void, pub wrapper: wrapperfunc, pub doc: *const ::std::os::raw::c_char, pub flags: ::std::os::raw::c_int, pub name_strobj: *mut PyObject, } impl Default for wrapperbase { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyTime_t = i64; pub type PyThread_type_lock = *mut ::std::os::raw::c_void; pub type Py_tss_t = _Py_tss_t; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_tss_t { pub _is_initialized: ::std::os::raw::c_int, pub _key: pthread_key_t, } pub type PyContext = _pycontextobject; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _PyOnceFlag { pub v: u8, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _PyArg_Parser { pub format: *const ::std::os::raw::c_char, pub keywords: *const *const ::std::os::raw::c_char, pub fname: *const ::std::os::raw::c_char, pub custom_msg: *const ::std::os::raw::c_char, pub once: _PyOnceFlag, pub is_kwtuple_owned: ::std::os::raw::c_int, pub pos: ::std::os::raw::c_int, pub min: ::std::os::raw::c_int, pub max: ::std::os::raw::c_int, pub kwtuple: *mut PyObject, pub next: *mut _PyArg_Parser, } impl Default for _PyArg_Parser { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type atexit_datacallbackfunc = ::std::option::Option; pub type Py_AuditHookFunction = ::std::option::Option< unsafe extern "C" fn( arg1: *const ::std::os::raw::c_char, arg2: *mut PyObject, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _inittab { pub name: *const ::std::os::raw::c_char, pub initfunc: ::std::option::Option *mut PyObject>, } impl Default for _inittab { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct PyEvent { pub v: u8, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _PyRecursiveMutex { pub mutex: PyMutex, pub thread: ::std::os::raw::c_ulonglong, pub level: usize, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _PyRWMutex { pub bits: usize, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct ast_state { pub once: _PyOnceFlag, pub finalized: ::std::os::raw::c_int, pub AST_type: *mut PyObject, pub Add_singleton: *mut PyObject, pub Add_type: *mut PyObject, pub And_singleton: *mut PyObject, pub And_type: *mut PyObject, pub AnnAssign_type: *mut PyObject, pub Assert_type: *mut PyObject, pub Assign_type: *mut PyObject, pub AsyncFor_type: *mut PyObject, pub AsyncFunctionDef_type: *mut PyObject, pub AsyncWith_type: *mut PyObject, pub Attribute_type: *mut PyObject, pub AugAssign_type: *mut PyObject, pub Await_type: *mut PyObject, pub BinOp_type: *mut PyObject, pub BitAnd_singleton: *mut PyObject, pub BitAnd_type: *mut PyObject, pub BitOr_singleton: *mut PyObject, pub BitOr_type: *mut PyObject, pub BitXor_singleton: *mut PyObject, pub BitXor_type: *mut PyObject, pub BoolOp_type: *mut PyObject, pub Break_type: *mut PyObject, pub Call_type: *mut PyObject, pub ClassDef_type: *mut PyObject, pub Compare_type: *mut PyObject, pub Constant_type: *mut PyObject, pub Continue_type: *mut PyObject, pub Del_singleton: *mut PyObject, pub Del_type: *mut PyObject, pub Delete_type: *mut PyObject, pub DictComp_type: *mut PyObject, pub Dict_type: *mut PyObject, pub Div_singleton: *mut PyObject, pub Div_type: *mut PyObject, pub Eq_singleton: *mut PyObject, pub Eq_type: *mut PyObject, pub ExceptHandler_type: *mut PyObject, pub Expr_type: *mut PyObject, pub Expression_type: *mut PyObject, pub FloorDiv_singleton: *mut PyObject, pub FloorDiv_type: *mut PyObject, pub For_type: *mut PyObject, pub FormattedValue_type: *mut PyObject, pub FunctionDef_type: *mut PyObject, pub FunctionType_type: *mut PyObject, pub GeneratorExp_type: *mut PyObject, pub Global_type: *mut PyObject, pub GtE_singleton: *mut PyObject, pub GtE_type: *mut PyObject, pub Gt_singleton: *mut PyObject, pub Gt_type: *mut PyObject, pub IfExp_type: *mut PyObject, pub If_type: *mut PyObject, pub ImportFrom_type: *mut PyObject, pub Import_type: *mut PyObject, pub In_singleton: *mut PyObject, pub In_type: *mut PyObject, pub Interactive_type: *mut PyObject, pub Invert_singleton: *mut PyObject, pub Invert_type: *mut PyObject, pub IsNot_singleton: *mut PyObject, pub IsNot_type: *mut PyObject, pub Is_singleton: *mut PyObject, pub Is_type: *mut PyObject, pub JoinedStr_type: *mut PyObject, pub LShift_singleton: *mut PyObject, pub LShift_type: *mut PyObject, pub Lambda_type: *mut PyObject, pub ListComp_type: *mut PyObject, pub List_type: *mut PyObject, pub Load_singleton: *mut PyObject, pub Load_type: *mut PyObject, pub LtE_singleton: *mut PyObject, pub LtE_type: *mut PyObject, pub Lt_singleton: *mut PyObject, pub Lt_type: *mut PyObject, pub MatMult_singleton: *mut PyObject, pub MatMult_type: *mut PyObject, pub MatchAs_type: *mut PyObject, pub MatchClass_type: *mut PyObject, pub MatchMapping_type: *mut PyObject, pub MatchOr_type: *mut PyObject, pub MatchSequence_type: *mut PyObject, pub MatchSingleton_type: *mut PyObject, pub MatchStar_type: *mut PyObject, pub MatchValue_type: *mut PyObject, pub Match_type: *mut PyObject, pub Mod_singleton: *mut PyObject, pub Mod_type: *mut PyObject, pub Module_type: *mut PyObject, pub Mult_singleton: *mut PyObject, pub Mult_type: *mut PyObject, pub Name_type: *mut PyObject, pub NamedExpr_type: *mut PyObject, pub Nonlocal_type: *mut PyObject, pub NotEq_singleton: *mut PyObject, pub NotEq_type: *mut PyObject, pub NotIn_singleton: *mut PyObject, pub NotIn_type: *mut PyObject, pub Not_singleton: *mut PyObject, pub Not_type: *mut PyObject, pub Or_singleton: *mut PyObject, pub Or_type: *mut PyObject, pub ParamSpec_type: *mut PyObject, pub Pass_type: *mut PyObject, pub Pow_singleton: *mut PyObject, pub Pow_type: *mut PyObject, pub RShift_singleton: *mut PyObject, pub RShift_type: *mut PyObject, pub Raise_type: *mut PyObject, pub Return_type: *mut PyObject, pub SetComp_type: *mut PyObject, pub Set_type: *mut PyObject, pub Slice_type: *mut PyObject, pub Starred_type: *mut PyObject, pub Store_singleton: *mut PyObject, pub Store_type: *mut PyObject, pub Sub_singleton: *mut PyObject, pub Sub_type: *mut PyObject, pub Subscript_type: *mut PyObject, pub TryStar_type: *mut PyObject, pub Try_type: *mut PyObject, pub Tuple_type: *mut PyObject, pub TypeAlias_type: *mut PyObject, pub TypeIgnore_type: *mut PyObject, pub TypeVarTuple_type: *mut PyObject, pub TypeVar_type: *mut PyObject, pub UAdd_singleton: *mut PyObject, pub UAdd_type: *mut PyObject, pub USub_singleton: *mut PyObject, pub USub_type: *mut PyObject, pub UnaryOp_type: *mut PyObject, pub While_type: *mut PyObject, pub With_type: *mut PyObject, pub YieldFrom_type: *mut PyObject, pub Yield_type: *mut PyObject, pub __dict__: *mut PyObject, pub __doc__: *mut PyObject, pub __match_args__: *mut PyObject, pub __module__: *mut PyObject, pub _attributes: *mut PyObject, pub _fields: *mut PyObject, pub alias_type: *mut PyObject, pub annotation: *mut PyObject, pub arg: *mut PyObject, pub arg_type: *mut PyObject, pub args: *mut PyObject, pub argtypes: *mut PyObject, pub arguments_type: *mut PyObject, pub asname: *mut PyObject, pub ast: *mut PyObject, pub attr: *mut PyObject, pub bases: *mut PyObject, pub body: *mut PyObject, pub boolop_type: *mut PyObject, pub bound: *mut PyObject, pub cases: *mut PyObject, pub cause: *mut PyObject, pub cls: *mut PyObject, pub cmpop_type: *mut PyObject, pub col_offset: *mut PyObject, pub comparators: *mut PyObject, pub comprehension_type: *mut PyObject, pub context_expr: *mut PyObject, pub conversion: *mut PyObject, pub ctx: *mut PyObject, pub decorator_list: *mut PyObject, pub default_value: *mut PyObject, pub defaults: *mut PyObject, pub elt: *mut PyObject, pub elts: *mut PyObject, pub end_col_offset: *mut PyObject, pub end_lineno: *mut PyObject, pub exc: *mut PyObject, pub excepthandler_type: *mut PyObject, pub expr_context_type: *mut PyObject, pub expr_type: *mut PyObject, pub finalbody: *mut PyObject, pub format_spec: *mut PyObject, pub func: *mut PyObject, pub generators: *mut PyObject, pub guard: *mut PyObject, pub handlers: *mut PyObject, pub id: *mut PyObject, pub ifs: *mut PyObject, pub is_async: *mut PyObject, pub items: *mut PyObject, pub iter: *mut PyObject, pub key: *mut PyObject, pub keys: *mut PyObject, pub keyword_type: *mut PyObject, pub keywords: *mut PyObject, pub kind: *mut PyObject, pub kw_defaults: *mut PyObject, pub kwarg: *mut PyObject, pub kwd_attrs: *mut PyObject, pub kwd_patterns: *mut PyObject, pub kwonlyargs: *mut PyObject, pub left: *mut PyObject, pub level: *mut PyObject, pub lineno: *mut PyObject, pub lower: *mut PyObject, pub match_case_type: *mut PyObject, pub mod_type: *mut PyObject, pub module: *mut PyObject, pub msg: *mut PyObject, pub name: *mut PyObject, pub names: *mut PyObject, pub op: *mut PyObject, pub operand: *mut PyObject, pub operator_type: *mut PyObject, pub ops: *mut PyObject, pub optional_vars: *mut PyObject, pub orelse: *mut PyObject, pub pattern: *mut PyObject, pub pattern_type: *mut PyObject, pub patterns: *mut PyObject, pub posonlyargs: *mut PyObject, pub rest: *mut PyObject, pub returns: *mut PyObject, pub right: *mut PyObject, pub simple: *mut PyObject, pub slice: *mut PyObject, pub step: *mut PyObject, pub stmt_type: *mut PyObject, pub subject: *mut PyObject, pub tag: *mut PyObject, pub target: *mut PyObject, pub targets: *mut PyObject, pub test: *mut PyObject, pub type_: *mut PyObject, pub type_comment: *mut PyObject, pub type_ignore_type: *mut PyObject, pub type_ignores: *mut PyObject, pub type_param_type: *mut PyObject, pub type_params: *mut PyObject, pub unaryop_type: *mut PyObject, pub upper: *mut PyObject, pub value: *mut PyObject, pub values: *mut PyObject, pub vararg: *mut PyObject, pub withitem_type: *mut PyObject, } impl Default for ast_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type atexit_callbackfunc = ::std::option::Option; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _atexit_runtime_state { pub mutex: PyMutex, pub callbacks: [atexit_callbackfunc; 32usize], pub ncallbacks: ::std::os::raw::c_int, } impl Default for _atexit_runtime_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct atexit_callback { pub func: atexit_datacallbackfunc, pub data: *mut ::std::os::raw::c_void, pub next: *mut atexit_callback, } impl Default for atexit_callback { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct atexit_py_callback { pub func: *mut PyObject, pub args: *mut PyObject, pub kwargs: *mut PyObject, } impl Default for atexit_py_callback { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct atexit_state { pub ll_callbacks: *mut atexit_callback, pub last_ll_callback: *mut atexit_callback, pub callbacks: *mut *mut atexit_py_callback, pub ncallbacks: ::std::os::raw::c_int, pub callback_len: ::std::os::raw::c_int, } impl Default for atexit_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct llist_node { pub next: *mut llist_node, pub prev: *mut llist_node, } impl Default for llist_node { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _pythread_runtime_state { pub initialized: ::std::os::raw::c_int, pub _condattr_monotonic: _pythread_runtime_state__bindgen_ty_1, pub handles: llist_node, } #[repr(C)] #[derive(Copy, Clone)] pub struct _pythread_runtime_state__bindgen_ty_1 { pub ptr: *mut pthread_condattr_t, pub val: pthread_condattr_t, } impl Default for _pythread_runtime_state__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for _pythread_runtime_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _gil_runtime_state { pub interval: ::std::os::raw::c_ulong, pub last_holder: *mut PyThreadState, pub locked: ::std::os::raw::c_int, pub switch_number: ::std::os::raw::c_ulong, pub cond: pthread_cond_t, pub mutex: pthread_mutex_t, pub switch_cond: pthread_cond_t, pub switch_mutex: pthread_mutex_t, } impl Default for _gil_runtime_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type _Py_pending_call_func = ::std::option::Option< unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _pending_call { pub func: _Py_pending_call_func, pub arg: *mut ::std::os::raw::c_void, pub flags: ::std::os::raw::c_int, } impl Default for _pending_call { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _pending_calls { pub handling_thread: *mut PyThreadState, pub mutex: PyMutex, pub npending: i32, pub max: i32, pub maxloop: i32, pub calls: [_pending_call; 300usize], pub first: ::std::os::raw::c_int, pub next: ::std::os::raw::c_int, } impl Default for _pending_calls { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _ceval_runtime_state { pub perf: _ceval_runtime_state__bindgen_ty_1, pub pending_mainthread: _pending_calls, pub sys_trace_profile_mutex: PyMutex, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _ceval_runtime_state__bindgen_ty_1 { pub _not_used: ::std::os::raw::c_int, } impl Default for _ceval_runtime_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _ceval_state { pub instrumentation_version: usize, pub recursion_limit: ::std::os::raw::c_int, pub gil: *mut _gil_runtime_state, pub own_gil: ::std::os::raw::c_int, pub pending: _pending_calls, } impl Default for _ceval_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_BackoffCounter { pub __bindgen_anon_1: _Py_BackoffCounter__bindgen_ty_1, } #[repr(C)] #[derive(Copy, Clone)] pub union _Py_BackoffCounter__bindgen_ty_1 { pub __bindgen_anon_1: _Py_BackoffCounter__bindgen_ty_1__bindgen_ty_1, pub as_counter: u16, _bindgen_union_align: u16, } #[repr(C)] #[repr(align(2))] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_BackoffCounter__bindgen_ty_1__bindgen_ty_1 { pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u16>, } impl _Py_BackoffCounter__bindgen_ty_1__bindgen_ty_1 { #[inline] pub fn backoff(&self) -> u16 { unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u16) } } #[inline] pub fn set_backoff(&mut self, val: u16) { unsafe { let val: u16 = ::std::mem::transmute(val); self._bitfield_1.set(0usize, 4u8, val as u64) } } #[inline] pub fn value(&self) -> u16 { unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 12u8) as u16) } } #[inline] pub fn set_value(&mut self, val: u16) { unsafe { let val: u16 = ::std::mem::transmute(val); self._bitfield_1.set(4usize, 12u8, val as u64) } } #[inline] pub fn new_bitfield_1(backoff: u16, value: u16) -> __BindgenBitfieldUnit<[u8; 2usize], u16> { let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u16> = Default::default(); __bindgen_bitfield_unit.set(0usize, 4u8, { let backoff: u16 = unsafe { ::std::mem::transmute(backoff) }; backoff as u64 }); __bindgen_bitfield_unit.set(4usize, 12u8, { let value: u16 = unsafe { ::std::mem::transmute(value) }; value as u64 }); __bindgen_bitfield_unit } } impl Default for _Py_BackoffCounter__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for _Py_BackoffCounter { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub union _Py_CODEUNIT { pub cache: u16, pub op: _Py_CODEUNIT__bindgen_ty_1, pub counter: _Py_BackoffCounter, _bindgen_union_align: u16, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_CODEUNIT__bindgen_ty_1 { pub code: u8, pub arg: u8, } impl Default for _Py_CODEUNIT { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _py_code_state { pub mutex: PyMutex, pub constants: *mut _Py_hashtable_t, } impl Default for _py_code_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct callable_cache { pub isinstance: *mut PyObject, pub len: *mut PyObject, pub list_append: *mut PyObject, pub object__getattribute__: *mut PyObject, } impl Default for callable_cache { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct codecs_state { pub search_path: *mut PyObject, pub search_cache: *mut PyObject, pub error_registry: *mut PyObject, pub initialized: ::std::os::raw::c_int, } impl Default for codecs_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_list_freelist { pub items: [*mut PyListObject; 80usize], pub numfree: ::std::os::raw::c_int, } impl Default for _Py_list_freelist { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_tuple_freelist { pub items: [*mut PyTupleObject; 20usize], pub numfree: [::std::os::raw::c_int; 20usize], } impl Default for _Py_tuple_freelist { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_float_freelist { pub numfree: ::std::os::raw::c_int, pub items: *mut PyFloatObject, } impl Default for _Py_float_freelist { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_dict_freelist { pub items: [*mut PyDictObject; 80usize], pub numfree: ::std::os::raw::c_int, } impl Default for _Py_dict_freelist { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_dictkeys_freelist { pub items: [*mut PyDictKeysObject; 80usize], pub numfree: ::std::os::raw::c_int, } impl Default for _Py_dictkeys_freelist { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_slice_freelist { pub slice_cache: *mut PySliceObject, } impl Default for _Py_slice_freelist { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_context_freelist { pub items: *mut PyContext, pub numfree: ::std::os::raw::c_int, } impl Default for _Py_context_freelist { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_async_gen_freelist { pub items: [*mut _PyAsyncGenWrappedValue; 80usize], pub numfree: ::std::os::raw::c_int, } impl Default for _Py_async_gen_freelist { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_async_gen_asend_freelist { pub items: [*mut PyAsyncGenASend; 80usize], pub numfree: ::std::os::raw::c_int, } impl Default for _Py_async_gen_asend_freelist { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_object_stack_freelist { pub items: *mut _PyObjectStackChunk, pub numfree: Py_ssize_t, } impl Default for _Py_object_stack_freelist { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_object_freelists { pub floats: _Py_float_freelist, pub tuples: _Py_tuple_freelist, pub lists: _Py_list_freelist, pub dicts: _Py_dict_freelist, pub dictkeys: _Py_dictkeys_freelist, pub slices: _Py_slice_freelist, pub contexts: _Py_context_freelist, pub async_gens: _Py_async_gen_freelist, pub async_gen_asends: _Py_async_gen_asend_freelist, pub object_stacks: _Py_object_stack_freelist, } impl Default for _Py_object_freelists { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct PyHamtNode { pub ob_base: PyObject, } impl Default for PyHamtNode { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct PyHamtObject { pub ob_base: PyObject, pub h_root: *mut PyHamtNode, pub h_weakreflist: *mut PyObject, pub h_count: Py_ssize_t, } impl Default for PyHamtObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct PyHamtNode_Bitmap { pub ob_base: PyVarObject, pub b_bitmap: u32, pub b_array: [*mut PyObject; 1usize], } impl Default for PyHamtNode_Bitmap { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _PyContextTokenMissing { pub ob_base: PyObject, } impl Default for _PyContextTokenMissing { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _pycontextobject { pub ob_base: PyObject, pub ctx_prev: *mut PyContext, pub ctx_vars: *mut PyHamtObject, pub ctx_weakreflist: *mut PyObject, pub ctx_entered: ::std::os::raw::c_int, } impl Default for _pycontextobject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type _PyCrossInterpreterData = _xid; pub type xid_newobjectfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut _PyCrossInterpreterData) -> *mut PyObject, >; pub type xid_freefunc = ::std::option::Option; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _xid { pub data: *mut ::std::os::raw::c_void, pub obj: *mut PyObject, pub interpid: i64, pub new_object: xid_newobjectfunc, pub free: xid_freefunc, } impl Default for _xid { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type crossinterpdatafunc = ::std::option::Option< unsafe extern "C" fn( tstate: *mut PyThreadState, arg1: *mut PyObject, arg2: *mut _PyCrossInterpreterData, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _xidregitem { pub prev: *mut _xidregitem, pub next: *mut _xidregitem, pub cls: *mut PyTypeObject, pub weakref: *mut PyObject, pub refcount: usize, pub getdata: crossinterpdatafunc, } impl Default for _xidregitem { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _xidregistry { pub global: ::std::os::raw::c_int, pub initialized: ::std::os::raw::c_int, pub mutex: PyMutex, pub head: *mut _xidregitem, } impl Default for _xidregistry { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _xi_runtime_state { pub registry: _xidregistry, } impl Default for _xi_runtime_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _xi_state { pub registry: _xidregistry, pub PyExc_NotShareableError: *mut PyObject, } impl Default for _xi_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_dict_state { pub global_version: u64, pub next_keys_version: u32, pub watchers: [PyDict_WatchCallback; 8usize], } impl Default for _Py_dict_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type ULong = u32; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct Bigint { pub next: *mut Bigint, pub k: ::std::os::raw::c_int, pub maxwds: ::std::os::raw::c_int, pub sign: ::std::os::raw::c_int, pub wds: ::std::os::raw::c_int, pub x: [ULong; 1usize], } impl Default for Bigint { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _dtoa_state { pub p5s: [*mut Bigint; 8usize], pub freelist: [*mut Bigint; 8usize], pub preallocated: [f64; 288usize], pub preallocated_next: *mut f64, } impl Default for _dtoa_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_exc_state { pub errnomap: *mut PyObject, pub memerrors_freelist: *mut PyBaseExceptionObject, pub memerrors_numfree: ::std::os::raw::c_int, pub PyExc_ExceptionGroup: *mut PyObject, } impl Default for _Py_exc_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _fileutils_state { pub force_ascii: ::std::os::raw::c_int, } pub const _Py_error_handler__Py_ERROR_UNKNOWN: _Py_error_handler = 0; pub const _Py_error_handler__Py_ERROR_STRICT: _Py_error_handler = 1; pub const _Py_error_handler__Py_ERROR_SURROGATEESCAPE: _Py_error_handler = 2; pub const _Py_error_handler__Py_ERROR_REPLACE: _Py_error_handler = 3; pub const _Py_error_handler__Py_ERROR_IGNORE: _Py_error_handler = 4; pub const _Py_error_handler__Py_ERROR_BACKSLASHREPLACE: _Py_error_handler = 5; pub const _Py_error_handler__Py_ERROR_SURROGATEPASS: _Py_error_handler = 6; pub const _Py_error_handler__Py_ERROR_XMLCHARREFREPLACE: _Py_error_handler = 7; pub const _Py_error_handler__Py_ERROR_OTHER: _Py_error_handler = 8; pub type _Py_error_handler = u32; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _PyUnicode_Name_CAPI { pub getname: ::std::option::Option< unsafe extern "C" fn( code: Py_UCS4, buffer: *mut ::std::os::raw::c_char, buflen: ::std::os::raw::c_int, with_alias_and_seq: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >, pub getcode: ::std::option::Option< unsafe extern "C" fn( name: *const ::std::os::raw::c_char, namelen: ::std::os::raw::c_int, code: *mut Py_UCS4, with_named_seq: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >, } impl Default for _PyUnicode_Name_CAPI { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct PyGC_Head { pub _gc_next: usize, pub _gc_prev: usize, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct gc_generation { pub head: PyGC_Head, pub threshold: ::std::os::raw::c_int, pub count: ::std::os::raw::c_int, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct gc_generation_stats { pub collections: Py_ssize_t, pub collected: Py_ssize_t, pub uncollectable: Py_ssize_t, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _gc_runtime_state { pub trash_delete_later: *mut PyObject, pub trash_delete_nesting: ::std::os::raw::c_int, pub enabled: ::std::os::raw::c_int, pub debug: ::std::os::raw::c_int, pub generations: [gc_generation; 3usize], pub generation0: *mut PyGC_Head, pub permanent_generation: gc_generation, pub generation_stats: [gc_generation_stats; 3usize], pub collecting: ::std::os::raw::c_int, pub garbage: *mut PyObject, pub callbacks: *mut PyObject, pub long_lived_total: Py_ssize_t, pub long_lived_pending: Py_ssize_t, } impl Default for _gc_runtime_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings { pub literals: _Py_global_strings__bindgen_ty_1, pub identifiers: _Py_global_strings__bindgen_ty_2, pub ascii: [_Py_global_strings__bindgen_ty_3; 128usize], pub latin1: [_Py_global_strings__bindgen_ty_4; 128usize], } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1 { pub _py_anon_dictcomp: _Py_global_strings__bindgen_ty_1__bindgen_ty_1, pub _py_anon_genexpr: _Py_global_strings__bindgen_ty_1__bindgen_ty_2, pub _py_anon_lambda: _Py_global_strings__bindgen_ty_1__bindgen_ty_3, pub _py_anon_listcomp: _Py_global_strings__bindgen_ty_1__bindgen_ty_4, pub _py_anon_module: _Py_global_strings__bindgen_ty_1__bindgen_ty_5, pub _py_anon_null: _Py_global_strings__bindgen_ty_1__bindgen_ty_6, pub _py_anon_setcomp: _Py_global_strings__bindgen_ty_1__bindgen_ty_7, pub _py_anon_string: _Py_global_strings__bindgen_ty_1__bindgen_ty_8, pub _py_anon_unknown: _Py_global_strings__bindgen_ty_1__bindgen_ty_9, pub _py_dbl_close_br: _Py_global_strings__bindgen_ty_1__bindgen_ty_10, pub _py_dbl_open_br: _Py_global_strings__bindgen_ty_1__bindgen_ty_11, pub _py_dbl_percent: _Py_global_strings__bindgen_ty_1__bindgen_ty_12, pub _py_defaults: _Py_global_strings__bindgen_ty_1__bindgen_ty_13, pub _py_dot_locals: _Py_global_strings__bindgen_ty_1__bindgen_ty_14, pub _py_empty: _Py_global_strings__bindgen_ty_1__bindgen_ty_15, pub _py_generic_base: _Py_global_strings__bindgen_ty_1__bindgen_ty_16, pub _py_json_decoder: _Py_global_strings__bindgen_ty_1__bindgen_ty_17, pub _py_kwdefaults: _Py_global_strings__bindgen_ty_1__bindgen_ty_18, pub _py_list_err: _Py_global_strings__bindgen_ty_1__bindgen_ty_19, pub _py_type_params: _Py_global_strings__bindgen_ty_1__bindgen_ty_20, pub _py_utf_8: _Py_global_strings__bindgen_ty_1__bindgen_ty_21, } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_1 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_2 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_2 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_3 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_3 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_4 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_4 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_5 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_5 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_6 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_6 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_7 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_7 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_8 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_8 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_9 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_9 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_10 { pub _ascii: PyASCIIObject, pub _data: [u8; 3usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_10 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_11 { pub _ascii: PyASCIIObject, pub _data: [u8; 3usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_11 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_12 { pub _ascii: PyASCIIObject, pub _data: [u8; 3usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_12 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_13 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_13 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_14 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_14 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_15 { pub _ascii: PyASCIIObject, pub _data: [u8; 1usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_15 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_16 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_16 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_17 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_17 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_18 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_18 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_19 { pub _ascii: PyASCIIObject, pub _data: [u8; 24usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_19 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_20 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_20 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_21 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_1__bindgen_ty_21 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for _Py_global_strings__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2 { pub _py_CANCELLED: _Py_global_strings__bindgen_ty_2__bindgen_ty_1, pub _py_FINISHED: _Py_global_strings__bindgen_ty_2__bindgen_ty_2, pub _py_False: _Py_global_strings__bindgen_ty_2__bindgen_ty_3, pub _py_JSONDecodeError: _Py_global_strings__bindgen_ty_2__bindgen_ty_4, pub _py_PENDING: _Py_global_strings__bindgen_ty_2__bindgen_ty_5, pub _py_Py_Repr: _Py_global_strings__bindgen_ty_2__bindgen_ty_6, pub _py_TextIOWrapper: _Py_global_strings__bindgen_ty_2__bindgen_ty_7, pub _py_True: _Py_global_strings__bindgen_ty_2__bindgen_ty_8, pub _py_WarningMessage: _Py_global_strings__bindgen_ty_2__bindgen_ty_9, pub _py__WindowsConsoleIO: _Py_global_strings__bindgen_ty_2__bindgen_ty_10, pub _py___IOBase_closed: _Py_global_strings__bindgen_ty_2__bindgen_ty_11, pub _py___abc_tpflags__: _Py_global_strings__bindgen_ty_2__bindgen_ty_12, pub _py___abs__: _Py_global_strings__bindgen_ty_2__bindgen_ty_13, pub _py___abstractmethods__: _Py_global_strings__bindgen_ty_2__bindgen_ty_14, pub _py___add__: _Py_global_strings__bindgen_ty_2__bindgen_ty_15, pub _py___aenter__: _Py_global_strings__bindgen_ty_2__bindgen_ty_16, pub _py___aexit__: _Py_global_strings__bindgen_ty_2__bindgen_ty_17, pub _py___aiter__: _Py_global_strings__bindgen_ty_2__bindgen_ty_18, pub _py___all__: _Py_global_strings__bindgen_ty_2__bindgen_ty_19, pub _py___and__: _Py_global_strings__bindgen_ty_2__bindgen_ty_20, pub _py___anext__: _Py_global_strings__bindgen_ty_2__bindgen_ty_21, pub _py___annotations__: _Py_global_strings__bindgen_ty_2__bindgen_ty_22, pub _py___args__: _Py_global_strings__bindgen_ty_2__bindgen_ty_23, pub _py___await__: _Py_global_strings__bindgen_ty_2__bindgen_ty_24, pub _py___bases__: _Py_global_strings__bindgen_ty_2__bindgen_ty_25, pub _py___bool__: _Py_global_strings__bindgen_ty_2__bindgen_ty_26, pub _py___buffer__: _Py_global_strings__bindgen_ty_2__bindgen_ty_27, pub _py___build_class__: _Py_global_strings__bindgen_ty_2__bindgen_ty_28, pub _py___builtins__: _Py_global_strings__bindgen_ty_2__bindgen_ty_29, pub _py___bytes__: _Py_global_strings__bindgen_ty_2__bindgen_ty_30, pub _py___call__: _Py_global_strings__bindgen_ty_2__bindgen_ty_31, pub _py___cantrace__: _Py_global_strings__bindgen_ty_2__bindgen_ty_32, pub _py___class__: _Py_global_strings__bindgen_ty_2__bindgen_ty_33, pub _py___class_getitem__: _Py_global_strings__bindgen_ty_2__bindgen_ty_34, pub _py___classcell__: _Py_global_strings__bindgen_ty_2__bindgen_ty_35, pub _py___classdict__: _Py_global_strings__bindgen_ty_2__bindgen_ty_36, pub _py___classdictcell__: _Py_global_strings__bindgen_ty_2__bindgen_ty_37, pub _py___complex__: _Py_global_strings__bindgen_ty_2__bindgen_ty_38, pub _py___contains__: _Py_global_strings__bindgen_ty_2__bindgen_ty_39, pub _py___copy__: _Py_global_strings__bindgen_ty_2__bindgen_ty_40, pub _py___ctypes_from_outparam__: _Py_global_strings__bindgen_ty_2__bindgen_ty_41, pub _py___del__: _Py_global_strings__bindgen_ty_2__bindgen_ty_42, pub _py___delattr__: _Py_global_strings__bindgen_ty_2__bindgen_ty_43, pub _py___delete__: _Py_global_strings__bindgen_ty_2__bindgen_ty_44, pub _py___delitem__: _Py_global_strings__bindgen_ty_2__bindgen_ty_45, pub _py___dict__: _Py_global_strings__bindgen_ty_2__bindgen_ty_46, pub _py___dictoffset__: _Py_global_strings__bindgen_ty_2__bindgen_ty_47, pub _py___dir__: _Py_global_strings__bindgen_ty_2__bindgen_ty_48, pub _py___divmod__: _Py_global_strings__bindgen_ty_2__bindgen_ty_49, pub _py___doc__: _Py_global_strings__bindgen_ty_2__bindgen_ty_50, pub _py___enter__: _Py_global_strings__bindgen_ty_2__bindgen_ty_51, pub _py___eq__: _Py_global_strings__bindgen_ty_2__bindgen_ty_52, pub _py___exit__: _Py_global_strings__bindgen_ty_2__bindgen_ty_53, pub _py___file__: _Py_global_strings__bindgen_ty_2__bindgen_ty_54, pub _py___firstlineno__: _Py_global_strings__bindgen_ty_2__bindgen_ty_55, pub _py___float__: _Py_global_strings__bindgen_ty_2__bindgen_ty_56, pub _py___floordiv__: _Py_global_strings__bindgen_ty_2__bindgen_ty_57, pub _py___format__: _Py_global_strings__bindgen_ty_2__bindgen_ty_58, pub _py___fspath__: _Py_global_strings__bindgen_ty_2__bindgen_ty_59, pub _py___ge__: _Py_global_strings__bindgen_ty_2__bindgen_ty_60, pub _py___get__: _Py_global_strings__bindgen_ty_2__bindgen_ty_61, pub _py___getattr__: _Py_global_strings__bindgen_ty_2__bindgen_ty_62, pub _py___getattribute__: _Py_global_strings__bindgen_ty_2__bindgen_ty_63, pub _py___getinitargs__: _Py_global_strings__bindgen_ty_2__bindgen_ty_64, pub _py___getitem__: _Py_global_strings__bindgen_ty_2__bindgen_ty_65, pub _py___getnewargs__: _Py_global_strings__bindgen_ty_2__bindgen_ty_66, pub _py___getnewargs_ex__: _Py_global_strings__bindgen_ty_2__bindgen_ty_67, pub _py___getstate__: _Py_global_strings__bindgen_ty_2__bindgen_ty_68, pub _py___gt__: _Py_global_strings__bindgen_ty_2__bindgen_ty_69, pub _py___hash__: _Py_global_strings__bindgen_ty_2__bindgen_ty_70, pub _py___iadd__: _Py_global_strings__bindgen_ty_2__bindgen_ty_71, pub _py___iand__: _Py_global_strings__bindgen_ty_2__bindgen_ty_72, pub _py___ifloordiv__: _Py_global_strings__bindgen_ty_2__bindgen_ty_73, pub _py___ilshift__: _Py_global_strings__bindgen_ty_2__bindgen_ty_74, pub _py___imatmul__: _Py_global_strings__bindgen_ty_2__bindgen_ty_75, pub _py___imod__: _Py_global_strings__bindgen_ty_2__bindgen_ty_76, pub _py___import__: _Py_global_strings__bindgen_ty_2__bindgen_ty_77, pub _py___imul__: _Py_global_strings__bindgen_ty_2__bindgen_ty_78, pub _py___index__: _Py_global_strings__bindgen_ty_2__bindgen_ty_79, pub _py___init__: _Py_global_strings__bindgen_ty_2__bindgen_ty_80, pub _py___init_subclass__: _Py_global_strings__bindgen_ty_2__bindgen_ty_81, pub _py___instancecheck__: _Py_global_strings__bindgen_ty_2__bindgen_ty_82, pub _py___int__: _Py_global_strings__bindgen_ty_2__bindgen_ty_83, pub _py___invert__: _Py_global_strings__bindgen_ty_2__bindgen_ty_84, pub _py___ior__: _Py_global_strings__bindgen_ty_2__bindgen_ty_85, pub _py___ipow__: _Py_global_strings__bindgen_ty_2__bindgen_ty_86, pub _py___irshift__: _Py_global_strings__bindgen_ty_2__bindgen_ty_87, pub _py___isabstractmethod__: _Py_global_strings__bindgen_ty_2__bindgen_ty_88, pub _py___isub__: _Py_global_strings__bindgen_ty_2__bindgen_ty_89, pub _py___iter__: _Py_global_strings__bindgen_ty_2__bindgen_ty_90, pub _py___itruediv__: _Py_global_strings__bindgen_ty_2__bindgen_ty_91, pub _py___ixor__: _Py_global_strings__bindgen_ty_2__bindgen_ty_92, pub _py___le__: _Py_global_strings__bindgen_ty_2__bindgen_ty_93, pub _py___len__: _Py_global_strings__bindgen_ty_2__bindgen_ty_94, pub _py___length_hint__: _Py_global_strings__bindgen_ty_2__bindgen_ty_95, pub _py___lltrace__: _Py_global_strings__bindgen_ty_2__bindgen_ty_96, pub _py___loader__: _Py_global_strings__bindgen_ty_2__bindgen_ty_97, pub _py___lshift__: _Py_global_strings__bindgen_ty_2__bindgen_ty_98, pub _py___lt__: _Py_global_strings__bindgen_ty_2__bindgen_ty_99, pub _py___main__: _Py_global_strings__bindgen_ty_2__bindgen_ty_100, pub _py___match_args__: _Py_global_strings__bindgen_ty_2__bindgen_ty_101, pub _py___matmul__: _Py_global_strings__bindgen_ty_2__bindgen_ty_102, pub _py___missing__: _Py_global_strings__bindgen_ty_2__bindgen_ty_103, pub _py___mod__: _Py_global_strings__bindgen_ty_2__bindgen_ty_104, pub _py___module__: _Py_global_strings__bindgen_ty_2__bindgen_ty_105, pub _py___mro_entries__: _Py_global_strings__bindgen_ty_2__bindgen_ty_106, pub _py___mul__: _Py_global_strings__bindgen_ty_2__bindgen_ty_107, pub _py___name__: _Py_global_strings__bindgen_ty_2__bindgen_ty_108, pub _py___ne__: _Py_global_strings__bindgen_ty_2__bindgen_ty_109, pub _py___neg__: _Py_global_strings__bindgen_ty_2__bindgen_ty_110, pub _py___new__: _Py_global_strings__bindgen_ty_2__bindgen_ty_111, pub _py___newobj__: _Py_global_strings__bindgen_ty_2__bindgen_ty_112, pub _py___newobj_ex__: _Py_global_strings__bindgen_ty_2__bindgen_ty_113, pub _py___next__: _Py_global_strings__bindgen_ty_2__bindgen_ty_114, pub _py___notes__: _Py_global_strings__bindgen_ty_2__bindgen_ty_115, pub _py___or__: _Py_global_strings__bindgen_ty_2__bindgen_ty_116, pub _py___orig_class__: _Py_global_strings__bindgen_ty_2__bindgen_ty_117, pub _py___origin__: _Py_global_strings__bindgen_ty_2__bindgen_ty_118, pub _py___package__: _Py_global_strings__bindgen_ty_2__bindgen_ty_119, pub _py___parameters__: _Py_global_strings__bindgen_ty_2__bindgen_ty_120, pub _py___path__: _Py_global_strings__bindgen_ty_2__bindgen_ty_121, pub _py___pos__: _Py_global_strings__bindgen_ty_2__bindgen_ty_122, pub _py___pow__: _Py_global_strings__bindgen_ty_2__bindgen_ty_123, pub _py___prepare__: _Py_global_strings__bindgen_ty_2__bindgen_ty_124, pub _py___qualname__: _Py_global_strings__bindgen_ty_2__bindgen_ty_125, pub _py___radd__: _Py_global_strings__bindgen_ty_2__bindgen_ty_126, pub _py___rand__: _Py_global_strings__bindgen_ty_2__bindgen_ty_127, pub _py___rdivmod__: _Py_global_strings__bindgen_ty_2__bindgen_ty_128, pub _py___reduce__: _Py_global_strings__bindgen_ty_2__bindgen_ty_129, pub _py___reduce_ex__: _Py_global_strings__bindgen_ty_2__bindgen_ty_130, pub _py___release_buffer__: _Py_global_strings__bindgen_ty_2__bindgen_ty_131, pub _py___repr__: _Py_global_strings__bindgen_ty_2__bindgen_ty_132, pub _py___reversed__: _Py_global_strings__bindgen_ty_2__bindgen_ty_133, pub _py___rfloordiv__: _Py_global_strings__bindgen_ty_2__bindgen_ty_134, pub _py___rlshift__: _Py_global_strings__bindgen_ty_2__bindgen_ty_135, pub _py___rmatmul__: _Py_global_strings__bindgen_ty_2__bindgen_ty_136, pub _py___rmod__: _Py_global_strings__bindgen_ty_2__bindgen_ty_137, pub _py___rmul__: _Py_global_strings__bindgen_ty_2__bindgen_ty_138, pub _py___ror__: _Py_global_strings__bindgen_ty_2__bindgen_ty_139, pub _py___round__: _Py_global_strings__bindgen_ty_2__bindgen_ty_140, pub _py___rpow__: _Py_global_strings__bindgen_ty_2__bindgen_ty_141, pub _py___rrshift__: _Py_global_strings__bindgen_ty_2__bindgen_ty_142, pub _py___rshift__: _Py_global_strings__bindgen_ty_2__bindgen_ty_143, pub _py___rsub__: _Py_global_strings__bindgen_ty_2__bindgen_ty_144, pub _py___rtruediv__: _Py_global_strings__bindgen_ty_2__bindgen_ty_145, pub _py___rxor__: _Py_global_strings__bindgen_ty_2__bindgen_ty_146, pub _py___set__: _Py_global_strings__bindgen_ty_2__bindgen_ty_147, pub _py___set_name__: _Py_global_strings__bindgen_ty_2__bindgen_ty_148, pub _py___setattr__: _Py_global_strings__bindgen_ty_2__bindgen_ty_149, pub _py___setitem__: _Py_global_strings__bindgen_ty_2__bindgen_ty_150, pub _py___setstate__: _Py_global_strings__bindgen_ty_2__bindgen_ty_151, pub _py___sizeof__: _Py_global_strings__bindgen_ty_2__bindgen_ty_152, pub _py___slotnames__: _Py_global_strings__bindgen_ty_2__bindgen_ty_153, pub _py___slots__: _Py_global_strings__bindgen_ty_2__bindgen_ty_154, pub _py___spec__: _Py_global_strings__bindgen_ty_2__bindgen_ty_155, pub _py___static_attributes__: _Py_global_strings__bindgen_ty_2__bindgen_ty_156, pub _py___str__: _Py_global_strings__bindgen_ty_2__bindgen_ty_157, pub _py___sub__: _Py_global_strings__bindgen_ty_2__bindgen_ty_158, pub _py___subclasscheck__: _Py_global_strings__bindgen_ty_2__bindgen_ty_159, pub _py___subclasshook__: _Py_global_strings__bindgen_ty_2__bindgen_ty_160, pub _py___truediv__: _Py_global_strings__bindgen_ty_2__bindgen_ty_161, pub _py___trunc__: _Py_global_strings__bindgen_ty_2__bindgen_ty_162, pub _py___type_params__: _Py_global_strings__bindgen_ty_2__bindgen_ty_163, pub _py___typing_is_unpacked_typevartuple__: _Py_global_strings__bindgen_ty_2__bindgen_ty_164, pub _py___typing_prepare_subst__: _Py_global_strings__bindgen_ty_2__bindgen_ty_165, pub _py___typing_subst__: _Py_global_strings__bindgen_ty_2__bindgen_ty_166, pub _py___typing_unpacked_tuple_args__: _Py_global_strings__bindgen_ty_2__bindgen_ty_167, pub _py___warningregistry__: _Py_global_strings__bindgen_ty_2__bindgen_ty_168, pub _py___weaklistoffset__: _Py_global_strings__bindgen_ty_2__bindgen_ty_169, pub _py___weakref__: _Py_global_strings__bindgen_ty_2__bindgen_ty_170, pub _py___xor__: _Py_global_strings__bindgen_ty_2__bindgen_ty_171, pub _py__abc_impl: _Py_global_strings__bindgen_ty_2__bindgen_ty_172, pub _py__abstract_: _Py_global_strings__bindgen_ty_2__bindgen_ty_173, pub _py__active: _Py_global_strings__bindgen_ty_2__bindgen_ty_174, pub _py__align_: _Py_global_strings__bindgen_ty_2__bindgen_ty_175, pub _py__annotation: _Py_global_strings__bindgen_ty_2__bindgen_ty_176, pub _py__anonymous_: _Py_global_strings__bindgen_ty_2__bindgen_ty_177, pub _py__argtypes_: _Py_global_strings__bindgen_ty_2__bindgen_ty_178, pub _py__as_parameter_: _Py_global_strings__bindgen_ty_2__bindgen_ty_179, pub _py__asyncio_future_blocking: _Py_global_strings__bindgen_ty_2__bindgen_ty_180, pub _py__blksize: _Py_global_strings__bindgen_ty_2__bindgen_ty_181, pub _py__bootstrap: _Py_global_strings__bindgen_ty_2__bindgen_ty_182, pub _py__check_retval_: _Py_global_strings__bindgen_ty_2__bindgen_ty_183, pub _py__dealloc_warn: _Py_global_strings__bindgen_ty_2__bindgen_ty_184, pub _py__feature_version: _Py_global_strings__bindgen_ty_2__bindgen_ty_185, pub _py__field_types: _Py_global_strings__bindgen_ty_2__bindgen_ty_186, pub _py__fields_: _Py_global_strings__bindgen_ty_2__bindgen_ty_187, pub _py__finalizing: _Py_global_strings__bindgen_ty_2__bindgen_ty_188, pub _py__find_and_load: _Py_global_strings__bindgen_ty_2__bindgen_ty_189, pub _py__fix_up_module: _Py_global_strings__bindgen_ty_2__bindgen_ty_190, pub _py__flags_: _Py_global_strings__bindgen_ty_2__bindgen_ty_191, pub _py__get_sourcefile: _Py_global_strings__bindgen_ty_2__bindgen_ty_192, pub _py__handle_fromlist: _Py_global_strings__bindgen_ty_2__bindgen_ty_193, pub _py__initializing: _Py_global_strings__bindgen_ty_2__bindgen_ty_194, pub _py__io: _Py_global_strings__bindgen_ty_2__bindgen_ty_195, pub _py__is_text_encoding: _Py_global_strings__bindgen_ty_2__bindgen_ty_196, pub _py__length_: _Py_global_strings__bindgen_ty_2__bindgen_ty_197, pub _py__limbo: _Py_global_strings__bindgen_ty_2__bindgen_ty_198, pub _py__lock_unlock_module: _Py_global_strings__bindgen_ty_2__bindgen_ty_199, pub _py__loop: _Py_global_strings__bindgen_ty_2__bindgen_ty_200, pub _py__needs_com_addref_: _Py_global_strings__bindgen_ty_2__bindgen_ty_201, pub _py__only_immortal: _Py_global_strings__bindgen_ty_2__bindgen_ty_202, pub _py__pack_: _Py_global_strings__bindgen_ty_2__bindgen_ty_203, pub _py__restype_: _Py_global_strings__bindgen_ty_2__bindgen_ty_204, pub _py__showwarnmsg: _Py_global_strings__bindgen_ty_2__bindgen_ty_205, pub _py__shutdown: _Py_global_strings__bindgen_ty_2__bindgen_ty_206, pub _py__slotnames: _Py_global_strings__bindgen_ty_2__bindgen_ty_207, pub _py__strptime: _Py_global_strings__bindgen_ty_2__bindgen_ty_208, pub _py__strptime_datetime: _Py_global_strings__bindgen_ty_2__bindgen_ty_209, pub _py__swappedbytes_: _Py_global_strings__bindgen_ty_2__bindgen_ty_210, pub _py__type_: _Py_global_strings__bindgen_ty_2__bindgen_ty_211, pub _py__uninitialized_submodules: _Py_global_strings__bindgen_ty_2__bindgen_ty_212, pub _py__warn_unawaited_coroutine: _Py_global_strings__bindgen_ty_2__bindgen_ty_213, pub _py__xoptions: _Py_global_strings__bindgen_ty_2__bindgen_ty_214, pub _py_abs_tol: _Py_global_strings__bindgen_ty_2__bindgen_ty_215, pub _py_access: _Py_global_strings__bindgen_ty_2__bindgen_ty_216, pub _py_aclose: _Py_global_strings__bindgen_ty_2__bindgen_ty_217, pub _py_add: _Py_global_strings__bindgen_ty_2__bindgen_ty_218, pub _py_add_done_callback: _Py_global_strings__bindgen_ty_2__bindgen_ty_219, pub _py_after_in_child: _Py_global_strings__bindgen_ty_2__bindgen_ty_220, pub _py_after_in_parent: _Py_global_strings__bindgen_ty_2__bindgen_ty_221, pub _py_aggregate_class: _Py_global_strings__bindgen_ty_2__bindgen_ty_222, pub _py_alias: _Py_global_strings__bindgen_ty_2__bindgen_ty_223, pub _py_allow_code: _Py_global_strings__bindgen_ty_2__bindgen_ty_224, pub _py_append: _Py_global_strings__bindgen_ty_2__bindgen_ty_225, pub _py_arg: _Py_global_strings__bindgen_ty_2__bindgen_ty_226, pub _py_argdefs: _Py_global_strings__bindgen_ty_2__bindgen_ty_227, pub _py_args: _Py_global_strings__bindgen_ty_2__bindgen_ty_228, pub _py_arguments: _Py_global_strings__bindgen_ty_2__bindgen_ty_229, pub _py_argv: _Py_global_strings__bindgen_ty_2__bindgen_ty_230, pub _py_as_integer_ratio: _Py_global_strings__bindgen_ty_2__bindgen_ty_231, pub _py_asend: _Py_global_strings__bindgen_ty_2__bindgen_ty_232, pub _py_ast: _Py_global_strings__bindgen_ty_2__bindgen_ty_233, pub _py_athrow: _Py_global_strings__bindgen_ty_2__bindgen_ty_234, pub _py_attribute: _Py_global_strings__bindgen_ty_2__bindgen_ty_235, pub _py_authorizer_callback: _Py_global_strings__bindgen_ty_2__bindgen_ty_236, pub _py_autocommit: _Py_global_strings__bindgen_ty_2__bindgen_ty_237, pub _py_backtick: _Py_global_strings__bindgen_ty_2__bindgen_ty_238, pub _py_base: _Py_global_strings__bindgen_ty_2__bindgen_ty_239, pub _py_before: _Py_global_strings__bindgen_ty_2__bindgen_ty_240, pub _py_big: _Py_global_strings__bindgen_ty_2__bindgen_ty_241, pub _py_binary_form: _Py_global_strings__bindgen_ty_2__bindgen_ty_242, pub _py_block: _Py_global_strings__bindgen_ty_2__bindgen_ty_243, pub _py_bound: _Py_global_strings__bindgen_ty_2__bindgen_ty_244, pub _py_buffer: _Py_global_strings__bindgen_ty_2__bindgen_ty_245, pub _py_buffer_callback: _Py_global_strings__bindgen_ty_2__bindgen_ty_246, pub _py_buffer_size: _Py_global_strings__bindgen_ty_2__bindgen_ty_247, pub _py_buffering: _Py_global_strings__bindgen_ty_2__bindgen_ty_248, pub _py_buffers: _Py_global_strings__bindgen_ty_2__bindgen_ty_249, pub _py_bufsize: _Py_global_strings__bindgen_ty_2__bindgen_ty_250, pub _py_builtins: _Py_global_strings__bindgen_ty_2__bindgen_ty_251, pub _py_byteorder: _Py_global_strings__bindgen_ty_2__bindgen_ty_252, pub _py_bytes: _Py_global_strings__bindgen_ty_2__bindgen_ty_253, pub _py_bytes_per_sep: _Py_global_strings__bindgen_ty_2__bindgen_ty_254, pub _py_c_call: _Py_global_strings__bindgen_ty_2__bindgen_ty_255, pub _py_c_exception: _Py_global_strings__bindgen_ty_2__bindgen_ty_256, pub _py_c_return: _Py_global_strings__bindgen_ty_2__bindgen_ty_257, pub _py_cached_datetime_module: _Py_global_strings__bindgen_ty_2__bindgen_ty_258, pub _py_cached_statements: _Py_global_strings__bindgen_ty_2__bindgen_ty_259, pub _py_cadata: _Py_global_strings__bindgen_ty_2__bindgen_ty_260, pub _py_cafile: _Py_global_strings__bindgen_ty_2__bindgen_ty_261, pub _py_call: _Py_global_strings__bindgen_ty_2__bindgen_ty_262, pub _py_call_exception_handler: _Py_global_strings__bindgen_ty_2__bindgen_ty_263, pub _py_call_soon: _Py_global_strings__bindgen_ty_2__bindgen_ty_264, pub _py_callback: _Py_global_strings__bindgen_ty_2__bindgen_ty_265, pub _py_cancel: _Py_global_strings__bindgen_ty_2__bindgen_ty_266, pub _py_capath: _Py_global_strings__bindgen_ty_2__bindgen_ty_267, pub _py_category: _Py_global_strings__bindgen_ty_2__bindgen_ty_268, pub _py_cb_type: _Py_global_strings__bindgen_ty_2__bindgen_ty_269, pub _py_certfile: _Py_global_strings__bindgen_ty_2__bindgen_ty_270, pub _py_check_same_thread: _Py_global_strings__bindgen_ty_2__bindgen_ty_271, pub _py_clear: _Py_global_strings__bindgen_ty_2__bindgen_ty_272, pub _py_close: _Py_global_strings__bindgen_ty_2__bindgen_ty_273, pub _py_closed: _Py_global_strings__bindgen_ty_2__bindgen_ty_274, pub _py_closefd: _Py_global_strings__bindgen_ty_2__bindgen_ty_275, pub _py_closure: _Py_global_strings__bindgen_ty_2__bindgen_ty_276, pub _py_co_argcount: _Py_global_strings__bindgen_ty_2__bindgen_ty_277, pub _py_co_cellvars: _Py_global_strings__bindgen_ty_2__bindgen_ty_278, pub _py_co_code: _Py_global_strings__bindgen_ty_2__bindgen_ty_279, pub _py_co_consts: _Py_global_strings__bindgen_ty_2__bindgen_ty_280, pub _py_co_exceptiontable: _Py_global_strings__bindgen_ty_2__bindgen_ty_281, pub _py_co_filename: _Py_global_strings__bindgen_ty_2__bindgen_ty_282, pub _py_co_firstlineno: _Py_global_strings__bindgen_ty_2__bindgen_ty_283, pub _py_co_flags: _Py_global_strings__bindgen_ty_2__bindgen_ty_284, pub _py_co_freevars: _Py_global_strings__bindgen_ty_2__bindgen_ty_285, pub _py_co_kwonlyargcount: _Py_global_strings__bindgen_ty_2__bindgen_ty_286, pub _py_co_linetable: _Py_global_strings__bindgen_ty_2__bindgen_ty_287, pub _py_co_name: _Py_global_strings__bindgen_ty_2__bindgen_ty_288, pub _py_co_names: _Py_global_strings__bindgen_ty_2__bindgen_ty_289, pub _py_co_nlocals: _Py_global_strings__bindgen_ty_2__bindgen_ty_290, pub _py_co_posonlyargcount: _Py_global_strings__bindgen_ty_2__bindgen_ty_291, pub _py_co_qualname: _Py_global_strings__bindgen_ty_2__bindgen_ty_292, pub _py_co_stacksize: _Py_global_strings__bindgen_ty_2__bindgen_ty_293, pub _py_co_varnames: _Py_global_strings__bindgen_ty_2__bindgen_ty_294, pub _py_code: _Py_global_strings__bindgen_ty_2__bindgen_ty_295, pub _py_col_offset: _Py_global_strings__bindgen_ty_2__bindgen_ty_296, pub _py_command: _Py_global_strings__bindgen_ty_2__bindgen_ty_297, pub _py_comment_factory: _Py_global_strings__bindgen_ty_2__bindgen_ty_298, pub _py_compile_mode: _Py_global_strings__bindgen_ty_2__bindgen_ty_299, pub _py_consts: _Py_global_strings__bindgen_ty_2__bindgen_ty_300, pub _py_context: _Py_global_strings__bindgen_ty_2__bindgen_ty_301, pub _py_contravariant: _Py_global_strings__bindgen_ty_2__bindgen_ty_302, pub _py_cookie: _Py_global_strings__bindgen_ty_2__bindgen_ty_303, pub _py_copy: _Py_global_strings__bindgen_ty_2__bindgen_ty_304, pub _py_copyreg: _Py_global_strings__bindgen_ty_2__bindgen_ty_305, pub _py_coro: _Py_global_strings__bindgen_ty_2__bindgen_ty_306, pub _py_count: _Py_global_strings__bindgen_ty_2__bindgen_ty_307, pub _py_covariant: _Py_global_strings__bindgen_ty_2__bindgen_ty_308, pub _py_cwd: _Py_global_strings__bindgen_ty_2__bindgen_ty_309, pub _py_data: _Py_global_strings__bindgen_ty_2__bindgen_ty_310, pub _py_database: _Py_global_strings__bindgen_ty_2__bindgen_ty_311, pub _py_day: _Py_global_strings__bindgen_ty_2__bindgen_ty_312, pub _py_decode: _Py_global_strings__bindgen_ty_2__bindgen_ty_313, pub _py_decoder: _Py_global_strings__bindgen_ty_2__bindgen_ty_314, pub _py_default: _Py_global_strings__bindgen_ty_2__bindgen_ty_315, pub _py_defaultaction: _Py_global_strings__bindgen_ty_2__bindgen_ty_316, pub _py_delete: _Py_global_strings__bindgen_ty_2__bindgen_ty_317, pub _py_depth: _Py_global_strings__bindgen_ty_2__bindgen_ty_318, pub _py_desired_access: _Py_global_strings__bindgen_ty_2__bindgen_ty_319, pub _py_detect_types: _Py_global_strings__bindgen_ty_2__bindgen_ty_320, pub _py_deterministic: _Py_global_strings__bindgen_ty_2__bindgen_ty_321, pub _py_device: _Py_global_strings__bindgen_ty_2__bindgen_ty_322, pub _py_dict: _Py_global_strings__bindgen_ty_2__bindgen_ty_323, pub _py_dictcomp: _Py_global_strings__bindgen_ty_2__bindgen_ty_324, pub _py_difference_update: _Py_global_strings__bindgen_ty_2__bindgen_ty_325, pub _py_digest: _Py_global_strings__bindgen_ty_2__bindgen_ty_326, pub _py_digest_size: _Py_global_strings__bindgen_ty_2__bindgen_ty_327, pub _py_digestmod: _Py_global_strings__bindgen_ty_2__bindgen_ty_328, pub _py_dir_fd: _Py_global_strings__bindgen_ty_2__bindgen_ty_329, pub _py_discard: _Py_global_strings__bindgen_ty_2__bindgen_ty_330, pub _py_dispatch_table: _Py_global_strings__bindgen_ty_2__bindgen_ty_331, pub _py_displayhook: _Py_global_strings__bindgen_ty_2__bindgen_ty_332, pub _py_dklen: _Py_global_strings__bindgen_ty_2__bindgen_ty_333, pub _py_doc: _Py_global_strings__bindgen_ty_2__bindgen_ty_334, pub _py_dont_inherit: _Py_global_strings__bindgen_ty_2__bindgen_ty_335, pub _py_dst: _Py_global_strings__bindgen_ty_2__bindgen_ty_336, pub _py_dst_dir_fd: _Py_global_strings__bindgen_ty_2__bindgen_ty_337, pub _py_eager_start: _Py_global_strings__bindgen_ty_2__bindgen_ty_338, pub _py_effective_ids: _Py_global_strings__bindgen_ty_2__bindgen_ty_339, pub _py_element_factory: _Py_global_strings__bindgen_ty_2__bindgen_ty_340, pub _py_encode: _Py_global_strings__bindgen_ty_2__bindgen_ty_341, pub _py_encoding: _Py_global_strings__bindgen_ty_2__bindgen_ty_342, pub _py_end: _Py_global_strings__bindgen_ty_2__bindgen_ty_343, pub _py_end_col_offset: _Py_global_strings__bindgen_ty_2__bindgen_ty_344, pub _py_end_lineno: _Py_global_strings__bindgen_ty_2__bindgen_ty_345, pub _py_end_offset: _Py_global_strings__bindgen_ty_2__bindgen_ty_346, pub _py_endpos: _Py_global_strings__bindgen_ty_2__bindgen_ty_347, pub _py_entrypoint: _Py_global_strings__bindgen_ty_2__bindgen_ty_348, pub _py_env: _Py_global_strings__bindgen_ty_2__bindgen_ty_349, pub _py_errors: _Py_global_strings__bindgen_ty_2__bindgen_ty_350, pub _py_event: _Py_global_strings__bindgen_ty_2__bindgen_ty_351, pub _py_eventmask: _Py_global_strings__bindgen_ty_2__bindgen_ty_352, pub _py_exc_type: _Py_global_strings__bindgen_ty_2__bindgen_ty_353, pub _py_exc_value: _Py_global_strings__bindgen_ty_2__bindgen_ty_354, pub _py_excepthook: _Py_global_strings__bindgen_ty_2__bindgen_ty_355, pub _py_exception: _Py_global_strings__bindgen_ty_2__bindgen_ty_356, pub _py_existing_file_name: _Py_global_strings__bindgen_ty_2__bindgen_ty_357, pub _py_exp: _Py_global_strings__bindgen_ty_2__bindgen_ty_358, pub _py_extend: _Py_global_strings__bindgen_ty_2__bindgen_ty_359, pub _py_extra_tokens: _Py_global_strings__bindgen_ty_2__bindgen_ty_360, pub _py_facility: _Py_global_strings__bindgen_ty_2__bindgen_ty_361, pub _py_factory: _Py_global_strings__bindgen_ty_2__bindgen_ty_362, pub _py_false: _Py_global_strings__bindgen_ty_2__bindgen_ty_363, pub _py_family: _Py_global_strings__bindgen_ty_2__bindgen_ty_364, pub _py_fanout: _Py_global_strings__bindgen_ty_2__bindgen_ty_365, pub _py_fd: _Py_global_strings__bindgen_ty_2__bindgen_ty_366, pub _py_fd2: _Py_global_strings__bindgen_ty_2__bindgen_ty_367, pub _py_fdel: _Py_global_strings__bindgen_ty_2__bindgen_ty_368, pub _py_fget: _Py_global_strings__bindgen_ty_2__bindgen_ty_369, pub _py_file: _Py_global_strings__bindgen_ty_2__bindgen_ty_370, pub _py_file_actions: _Py_global_strings__bindgen_ty_2__bindgen_ty_371, pub _py_filename: _Py_global_strings__bindgen_ty_2__bindgen_ty_372, pub _py_fileno: _Py_global_strings__bindgen_ty_2__bindgen_ty_373, pub _py_filepath: _Py_global_strings__bindgen_ty_2__bindgen_ty_374, pub _py_fillvalue: _Py_global_strings__bindgen_ty_2__bindgen_ty_375, pub _py_filter: _Py_global_strings__bindgen_ty_2__bindgen_ty_376, pub _py_filters: _Py_global_strings__bindgen_ty_2__bindgen_ty_377, pub _py_final: _Py_global_strings__bindgen_ty_2__bindgen_ty_378, pub _py_find_class: _Py_global_strings__bindgen_ty_2__bindgen_ty_379, pub _py_fix_imports: _Py_global_strings__bindgen_ty_2__bindgen_ty_380, pub _py_flags: _Py_global_strings__bindgen_ty_2__bindgen_ty_381, pub _py_flush: _Py_global_strings__bindgen_ty_2__bindgen_ty_382, pub _py_fold: _Py_global_strings__bindgen_ty_2__bindgen_ty_383, pub _py_follow_symlinks: _Py_global_strings__bindgen_ty_2__bindgen_ty_384, pub _py_format: _Py_global_strings__bindgen_ty_2__bindgen_ty_385, pub _py_from_param: _Py_global_strings__bindgen_ty_2__bindgen_ty_386, pub _py_fromlist: _Py_global_strings__bindgen_ty_2__bindgen_ty_387, pub _py_fromtimestamp: _Py_global_strings__bindgen_ty_2__bindgen_ty_388, pub _py_fromutc: _Py_global_strings__bindgen_ty_2__bindgen_ty_389, pub _py_fset: _Py_global_strings__bindgen_ty_2__bindgen_ty_390, pub _py_func: _Py_global_strings__bindgen_ty_2__bindgen_ty_391, pub _py_future: _Py_global_strings__bindgen_ty_2__bindgen_ty_392, pub _py_generation: _Py_global_strings__bindgen_ty_2__bindgen_ty_393, pub _py_genexpr: _Py_global_strings__bindgen_ty_2__bindgen_ty_394, pub _py_get: _Py_global_strings__bindgen_ty_2__bindgen_ty_395, pub _py_get_debug: _Py_global_strings__bindgen_ty_2__bindgen_ty_396, pub _py_get_event_loop: _Py_global_strings__bindgen_ty_2__bindgen_ty_397, pub _py_get_loop: _Py_global_strings__bindgen_ty_2__bindgen_ty_398, pub _py_get_source: _Py_global_strings__bindgen_ty_2__bindgen_ty_399, pub _py_getattr: _Py_global_strings__bindgen_ty_2__bindgen_ty_400, pub _py_getstate: _Py_global_strings__bindgen_ty_2__bindgen_ty_401, pub _py_gid: _Py_global_strings__bindgen_ty_2__bindgen_ty_402, pub _py_globals: _Py_global_strings__bindgen_ty_2__bindgen_ty_403, pub _py_groupindex: _Py_global_strings__bindgen_ty_2__bindgen_ty_404, pub _py_groups: _Py_global_strings__bindgen_ty_2__bindgen_ty_405, pub _py_handle: _Py_global_strings__bindgen_ty_2__bindgen_ty_406, pub _py_handle_seq: _Py_global_strings__bindgen_ty_2__bindgen_ty_407, pub _py_has_location: _Py_global_strings__bindgen_ty_2__bindgen_ty_408, pub _py_hash_name: _Py_global_strings__bindgen_ty_2__bindgen_ty_409, pub _py_header: _Py_global_strings__bindgen_ty_2__bindgen_ty_410, pub _py_headers: _Py_global_strings__bindgen_ty_2__bindgen_ty_411, pub _py_hi: _Py_global_strings__bindgen_ty_2__bindgen_ty_412, pub _py_hook: _Py_global_strings__bindgen_ty_2__bindgen_ty_413, pub _py_hour: _Py_global_strings__bindgen_ty_2__bindgen_ty_414, pub _py_ident: _Py_global_strings__bindgen_ty_2__bindgen_ty_415, pub _py_identity_hint: _Py_global_strings__bindgen_ty_2__bindgen_ty_416, pub _py_ignore: _Py_global_strings__bindgen_ty_2__bindgen_ty_417, pub _py_imag: _Py_global_strings__bindgen_ty_2__bindgen_ty_418, pub _py_importlib: _Py_global_strings__bindgen_ty_2__bindgen_ty_419, pub _py_in_fd: _Py_global_strings__bindgen_ty_2__bindgen_ty_420, pub _py_incoming: _Py_global_strings__bindgen_ty_2__bindgen_ty_421, pub _py_indexgroup: _Py_global_strings__bindgen_ty_2__bindgen_ty_422, pub _py_inf: _Py_global_strings__bindgen_ty_2__bindgen_ty_423, pub _py_infer_variance: _Py_global_strings__bindgen_ty_2__bindgen_ty_424, pub _py_inherit_handle: _Py_global_strings__bindgen_ty_2__bindgen_ty_425, pub _py_inheritable: _Py_global_strings__bindgen_ty_2__bindgen_ty_426, pub _py_initial: _Py_global_strings__bindgen_ty_2__bindgen_ty_427, pub _py_initial_bytes: _Py_global_strings__bindgen_ty_2__bindgen_ty_428, pub _py_initial_owner: _Py_global_strings__bindgen_ty_2__bindgen_ty_429, pub _py_initial_state: _Py_global_strings__bindgen_ty_2__bindgen_ty_430, pub _py_initial_value: _Py_global_strings__bindgen_ty_2__bindgen_ty_431, pub _py_initval: _Py_global_strings__bindgen_ty_2__bindgen_ty_432, pub _py_inner_size: _Py_global_strings__bindgen_ty_2__bindgen_ty_433, pub _py_input: _Py_global_strings__bindgen_ty_2__bindgen_ty_434, pub _py_insert_comments: _Py_global_strings__bindgen_ty_2__bindgen_ty_435, pub _py_insert_pis: _Py_global_strings__bindgen_ty_2__bindgen_ty_436, pub _py_instructions: _Py_global_strings__bindgen_ty_2__bindgen_ty_437, pub _py_intern: _Py_global_strings__bindgen_ty_2__bindgen_ty_438, pub _py_intersection: _Py_global_strings__bindgen_ty_2__bindgen_ty_439, pub _py_interval: _Py_global_strings__bindgen_ty_2__bindgen_ty_440, pub _py_is_running: _Py_global_strings__bindgen_ty_2__bindgen_ty_441, pub _py_isatty: _Py_global_strings__bindgen_ty_2__bindgen_ty_442, pub _py_isinstance: _Py_global_strings__bindgen_ty_2__bindgen_ty_443, pub _py_isoformat: _Py_global_strings__bindgen_ty_2__bindgen_ty_444, pub _py_isolation_level: _Py_global_strings__bindgen_ty_2__bindgen_ty_445, pub _py_istext: _Py_global_strings__bindgen_ty_2__bindgen_ty_446, pub _py_item: _Py_global_strings__bindgen_ty_2__bindgen_ty_447, pub _py_items: _Py_global_strings__bindgen_ty_2__bindgen_ty_448, pub _py_iter: _Py_global_strings__bindgen_ty_2__bindgen_ty_449, pub _py_iterable: _Py_global_strings__bindgen_ty_2__bindgen_ty_450, pub _py_iterations: _Py_global_strings__bindgen_ty_2__bindgen_ty_451, pub _py_join: _Py_global_strings__bindgen_ty_2__bindgen_ty_452, pub _py_jump: _Py_global_strings__bindgen_ty_2__bindgen_ty_453, pub _py_keepends: _Py_global_strings__bindgen_ty_2__bindgen_ty_454, pub _py_key: _Py_global_strings__bindgen_ty_2__bindgen_ty_455, pub _py_keyfile: _Py_global_strings__bindgen_ty_2__bindgen_ty_456, pub _py_keys: _Py_global_strings__bindgen_ty_2__bindgen_ty_457, pub _py_kind: _Py_global_strings__bindgen_ty_2__bindgen_ty_458, pub _py_kw: _Py_global_strings__bindgen_ty_2__bindgen_ty_459, pub _py_kw1: _Py_global_strings__bindgen_ty_2__bindgen_ty_460, pub _py_kw2: _Py_global_strings__bindgen_ty_2__bindgen_ty_461, pub _py_kwdefaults: _Py_global_strings__bindgen_ty_2__bindgen_ty_462, pub _py_label: _Py_global_strings__bindgen_ty_2__bindgen_ty_463, pub _py_lambda: _Py_global_strings__bindgen_ty_2__bindgen_ty_464, pub _py_last: _Py_global_strings__bindgen_ty_2__bindgen_ty_465, pub _py_last_exc: _Py_global_strings__bindgen_ty_2__bindgen_ty_466, pub _py_last_node: _Py_global_strings__bindgen_ty_2__bindgen_ty_467, pub _py_last_traceback: _Py_global_strings__bindgen_ty_2__bindgen_ty_468, pub _py_last_type: _Py_global_strings__bindgen_ty_2__bindgen_ty_469, pub _py_last_value: _Py_global_strings__bindgen_ty_2__bindgen_ty_470, pub _py_latin1: _Py_global_strings__bindgen_ty_2__bindgen_ty_471, pub _py_leaf_size: _Py_global_strings__bindgen_ty_2__bindgen_ty_472, pub _py_len: _Py_global_strings__bindgen_ty_2__bindgen_ty_473, pub _py_length: _Py_global_strings__bindgen_ty_2__bindgen_ty_474, pub _py_level: _Py_global_strings__bindgen_ty_2__bindgen_ty_475, pub _py_limit: _Py_global_strings__bindgen_ty_2__bindgen_ty_476, pub _py_line: _Py_global_strings__bindgen_ty_2__bindgen_ty_477, pub _py_line_buffering: _Py_global_strings__bindgen_ty_2__bindgen_ty_478, pub _py_lineno: _Py_global_strings__bindgen_ty_2__bindgen_ty_479, pub _py_listcomp: _Py_global_strings__bindgen_ty_2__bindgen_ty_480, pub _py_little: _Py_global_strings__bindgen_ty_2__bindgen_ty_481, pub _py_lo: _Py_global_strings__bindgen_ty_2__bindgen_ty_482, pub _py_locale: _Py_global_strings__bindgen_ty_2__bindgen_ty_483, pub _py_locals: _Py_global_strings__bindgen_ty_2__bindgen_ty_484, pub _py_logoption: _Py_global_strings__bindgen_ty_2__bindgen_ty_485, pub _py_loop: _Py_global_strings__bindgen_ty_2__bindgen_ty_486, pub _py_manual_reset: _Py_global_strings__bindgen_ty_2__bindgen_ty_487, pub _py_mapping: _Py_global_strings__bindgen_ty_2__bindgen_ty_488, pub _py_match: _Py_global_strings__bindgen_ty_2__bindgen_ty_489, pub _py_max_length: _Py_global_strings__bindgen_ty_2__bindgen_ty_490, pub _py_maxdigits: _Py_global_strings__bindgen_ty_2__bindgen_ty_491, pub _py_maxevents: _Py_global_strings__bindgen_ty_2__bindgen_ty_492, pub _py_maxlen: _Py_global_strings__bindgen_ty_2__bindgen_ty_493, pub _py_maxmem: _Py_global_strings__bindgen_ty_2__bindgen_ty_494, pub _py_maxsplit: _Py_global_strings__bindgen_ty_2__bindgen_ty_495, pub _py_maxvalue: _Py_global_strings__bindgen_ty_2__bindgen_ty_496, pub _py_memLevel: _Py_global_strings__bindgen_ty_2__bindgen_ty_497, pub _py_memlimit: _Py_global_strings__bindgen_ty_2__bindgen_ty_498, pub _py_message: _Py_global_strings__bindgen_ty_2__bindgen_ty_499, pub _py_metaclass: _Py_global_strings__bindgen_ty_2__bindgen_ty_500, pub _py_metadata: _Py_global_strings__bindgen_ty_2__bindgen_ty_501, pub _py_method: _Py_global_strings__bindgen_ty_2__bindgen_ty_502, pub _py_microsecond: _Py_global_strings__bindgen_ty_2__bindgen_ty_503, pub _py_milliseconds: _Py_global_strings__bindgen_ty_2__bindgen_ty_504, pub _py_minute: _Py_global_strings__bindgen_ty_2__bindgen_ty_505, pub _py_mod: _Py_global_strings__bindgen_ty_2__bindgen_ty_506, pub _py_mode: _Py_global_strings__bindgen_ty_2__bindgen_ty_507, pub _py_module: _Py_global_strings__bindgen_ty_2__bindgen_ty_508, pub _py_module_globals: _Py_global_strings__bindgen_ty_2__bindgen_ty_509, pub _py_modules: _Py_global_strings__bindgen_ty_2__bindgen_ty_510, pub _py_month: _Py_global_strings__bindgen_ty_2__bindgen_ty_511, pub _py_mro: _Py_global_strings__bindgen_ty_2__bindgen_ty_512, pub _py_msg: _Py_global_strings__bindgen_ty_2__bindgen_ty_513, pub _py_mutex: _Py_global_strings__bindgen_ty_2__bindgen_ty_514, pub _py_mycmp: _Py_global_strings__bindgen_ty_2__bindgen_ty_515, pub _py_n_arg: _Py_global_strings__bindgen_ty_2__bindgen_ty_516, pub _py_n_fields: _Py_global_strings__bindgen_ty_2__bindgen_ty_517, pub _py_n_sequence_fields: _Py_global_strings__bindgen_ty_2__bindgen_ty_518, pub _py_n_unnamed_fields: _Py_global_strings__bindgen_ty_2__bindgen_ty_519, pub _py_name: _Py_global_strings__bindgen_ty_2__bindgen_ty_520, pub _py_name_from: _Py_global_strings__bindgen_ty_2__bindgen_ty_521, pub _py_namespace_separator: _Py_global_strings__bindgen_ty_2__bindgen_ty_522, pub _py_namespaces: _Py_global_strings__bindgen_ty_2__bindgen_ty_523, pub _py_narg: _Py_global_strings__bindgen_ty_2__bindgen_ty_524, pub _py_ndigits: _Py_global_strings__bindgen_ty_2__bindgen_ty_525, pub _py_nested: _Py_global_strings__bindgen_ty_2__bindgen_ty_526, pub _py_new_file_name: _Py_global_strings__bindgen_ty_2__bindgen_ty_527, pub _py_new_limit: _Py_global_strings__bindgen_ty_2__bindgen_ty_528, pub _py_newline: _Py_global_strings__bindgen_ty_2__bindgen_ty_529, pub _py_newlines: _Py_global_strings__bindgen_ty_2__bindgen_ty_530, pub _py_next: _Py_global_strings__bindgen_ty_2__bindgen_ty_531, pub _py_nlocals: _Py_global_strings__bindgen_ty_2__bindgen_ty_532, pub _py_node_depth: _Py_global_strings__bindgen_ty_2__bindgen_ty_533, pub _py_node_offset: _Py_global_strings__bindgen_ty_2__bindgen_ty_534, pub _py_ns: _Py_global_strings__bindgen_ty_2__bindgen_ty_535, pub _py_nstype: _Py_global_strings__bindgen_ty_2__bindgen_ty_536, pub _py_nt: _Py_global_strings__bindgen_ty_2__bindgen_ty_537, pub _py_null: _Py_global_strings__bindgen_ty_2__bindgen_ty_538, pub _py_number: _Py_global_strings__bindgen_ty_2__bindgen_ty_539, pub _py_obj: _Py_global_strings__bindgen_ty_2__bindgen_ty_540, pub _py_object: _Py_global_strings__bindgen_ty_2__bindgen_ty_541, pub _py_offset: _Py_global_strings__bindgen_ty_2__bindgen_ty_542, pub _py_offset_dst: _Py_global_strings__bindgen_ty_2__bindgen_ty_543, pub _py_offset_src: _Py_global_strings__bindgen_ty_2__bindgen_ty_544, pub _py_on_type_read: _Py_global_strings__bindgen_ty_2__bindgen_ty_545, pub _py_onceregistry: _Py_global_strings__bindgen_ty_2__bindgen_ty_546, pub _py_only_keys: _Py_global_strings__bindgen_ty_2__bindgen_ty_547, pub _py_oparg: _Py_global_strings__bindgen_ty_2__bindgen_ty_548, pub _py_opcode: _Py_global_strings__bindgen_ty_2__bindgen_ty_549, pub _py_open: _Py_global_strings__bindgen_ty_2__bindgen_ty_550, pub _py_opener: _Py_global_strings__bindgen_ty_2__bindgen_ty_551, pub _py_operation: _Py_global_strings__bindgen_ty_2__bindgen_ty_552, pub _py_optimize: _Py_global_strings__bindgen_ty_2__bindgen_ty_553, pub _py_options: _Py_global_strings__bindgen_ty_2__bindgen_ty_554, pub _py_order: _Py_global_strings__bindgen_ty_2__bindgen_ty_555, pub _py_origin: _Py_global_strings__bindgen_ty_2__bindgen_ty_556, pub _py_out_fd: _Py_global_strings__bindgen_ty_2__bindgen_ty_557, pub _py_outgoing: _Py_global_strings__bindgen_ty_2__bindgen_ty_558, pub _py_overlapped: _Py_global_strings__bindgen_ty_2__bindgen_ty_559, pub _py_owner: _Py_global_strings__bindgen_ty_2__bindgen_ty_560, pub _py_pages: _Py_global_strings__bindgen_ty_2__bindgen_ty_561, pub _py_parent: _Py_global_strings__bindgen_ty_2__bindgen_ty_562, pub _py_password: _Py_global_strings__bindgen_ty_2__bindgen_ty_563, pub _py_path: _Py_global_strings__bindgen_ty_2__bindgen_ty_564, pub _py_pattern: _Py_global_strings__bindgen_ty_2__bindgen_ty_565, pub _py_peek: _Py_global_strings__bindgen_ty_2__bindgen_ty_566, pub _py_persistent_id: _Py_global_strings__bindgen_ty_2__bindgen_ty_567, pub _py_persistent_load: _Py_global_strings__bindgen_ty_2__bindgen_ty_568, pub _py_person: _Py_global_strings__bindgen_ty_2__bindgen_ty_569, pub _py_pi_factory: _Py_global_strings__bindgen_ty_2__bindgen_ty_570, pub _py_pid: _Py_global_strings__bindgen_ty_2__bindgen_ty_571, pub _py_policy: _Py_global_strings__bindgen_ty_2__bindgen_ty_572, pub _py_pos: _Py_global_strings__bindgen_ty_2__bindgen_ty_573, pub _py_pos1: _Py_global_strings__bindgen_ty_2__bindgen_ty_574, pub _py_pos2: _Py_global_strings__bindgen_ty_2__bindgen_ty_575, pub _py_posix: _Py_global_strings__bindgen_ty_2__bindgen_ty_576, pub _py_print_file_and_line: _Py_global_strings__bindgen_ty_2__bindgen_ty_577, pub _py_priority: _Py_global_strings__bindgen_ty_2__bindgen_ty_578, pub _py_progress: _Py_global_strings__bindgen_ty_2__bindgen_ty_579, pub _py_progress_handler: _Py_global_strings__bindgen_ty_2__bindgen_ty_580, pub _py_progress_routine: _Py_global_strings__bindgen_ty_2__bindgen_ty_581, pub _py_proto: _Py_global_strings__bindgen_ty_2__bindgen_ty_582, pub _py_protocol: _Py_global_strings__bindgen_ty_2__bindgen_ty_583, pub _py_ps1: _Py_global_strings__bindgen_ty_2__bindgen_ty_584, pub _py_ps2: _Py_global_strings__bindgen_ty_2__bindgen_ty_585, pub _py_query: _Py_global_strings__bindgen_ty_2__bindgen_ty_586, pub _py_quotetabs: _Py_global_strings__bindgen_ty_2__bindgen_ty_587, pub _py_raw: _Py_global_strings__bindgen_ty_2__bindgen_ty_588, pub _py_read: _Py_global_strings__bindgen_ty_2__bindgen_ty_589, pub _py_read1: _Py_global_strings__bindgen_ty_2__bindgen_ty_590, pub _py_readable: _Py_global_strings__bindgen_ty_2__bindgen_ty_591, pub _py_readall: _Py_global_strings__bindgen_ty_2__bindgen_ty_592, pub _py_readinto: _Py_global_strings__bindgen_ty_2__bindgen_ty_593, pub _py_readinto1: _Py_global_strings__bindgen_ty_2__bindgen_ty_594, pub _py_readline: _Py_global_strings__bindgen_ty_2__bindgen_ty_595, pub _py_readonly: _Py_global_strings__bindgen_ty_2__bindgen_ty_596, pub _py_real: _Py_global_strings__bindgen_ty_2__bindgen_ty_597, pub _py_reducer_override: _Py_global_strings__bindgen_ty_2__bindgen_ty_598, pub _py_registry: _Py_global_strings__bindgen_ty_2__bindgen_ty_599, pub _py_rel_tol: _Py_global_strings__bindgen_ty_2__bindgen_ty_600, pub _py_release: _Py_global_strings__bindgen_ty_2__bindgen_ty_601, pub _py_reload: _Py_global_strings__bindgen_ty_2__bindgen_ty_602, pub _py_repl: _Py_global_strings__bindgen_ty_2__bindgen_ty_603, pub _py_replace: _Py_global_strings__bindgen_ty_2__bindgen_ty_604, pub _py_reserved: _Py_global_strings__bindgen_ty_2__bindgen_ty_605, pub _py_reset: _Py_global_strings__bindgen_ty_2__bindgen_ty_606, pub _py_resetids: _Py_global_strings__bindgen_ty_2__bindgen_ty_607, pub _py_return: _Py_global_strings__bindgen_ty_2__bindgen_ty_608, pub _py_reverse: _Py_global_strings__bindgen_ty_2__bindgen_ty_609, pub _py_reversed: _Py_global_strings__bindgen_ty_2__bindgen_ty_610, pub _py_salt: _Py_global_strings__bindgen_ty_2__bindgen_ty_611, pub _py_sched_priority: _Py_global_strings__bindgen_ty_2__bindgen_ty_612, pub _py_scheduler: _Py_global_strings__bindgen_ty_2__bindgen_ty_613, pub _py_second: _Py_global_strings__bindgen_ty_2__bindgen_ty_614, pub _py_security_attributes: _Py_global_strings__bindgen_ty_2__bindgen_ty_615, pub _py_seek: _Py_global_strings__bindgen_ty_2__bindgen_ty_616, pub _py_seekable: _Py_global_strings__bindgen_ty_2__bindgen_ty_617, pub _py_selectors: _Py_global_strings__bindgen_ty_2__bindgen_ty_618, pub _py_self: _Py_global_strings__bindgen_ty_2__bindgen_ty_619, pub _py_send: _Py_global_strings__bindgen_ty_2__bindgen_ty_620, pub _py_sep: _Py_global_strings__bindgen_ty_2__bindgen_ty_621, pub _py_sequence: _Py_global_strings__bindgen_ty_2__bindgen_ty_622, pub _py_server_hostname: _Py_global_strings__bindgen_ty_2__bindgen_ty_623, pub _py_server_side: _Py_global_strings__bindgen_ty_2__bindgen_ty_624, pub _py_session: _Py_global_strings__bindgen_ty_2__bindgen_ty_625, pub _py_setcomp: _Py_global_strings__bindgen_ty_2__bindgen_ty_626, pub _py_setpgroup: _Py_global_strings__bindgen_ty_2__bindgen_ty_627, pub _py_setsid: _Py_global_strings__bindgen_ty_2__bindgen_ty_628, pub _py_setsigdef: _Py_global_strings__bindgen_ty_2__bindgen_ty_629, pub _py_setsigmask: _Py_global_strings__bindgen_ty_2__bindgen_ty_630, pub _py_setstate: _Py_global_strings__bindgen_ty_2__bindgen_ty_631, pub _py_shape: _Py_global_strings__bindgen_ty_2__bindgen_ty_632, pub _py_show_cmd: _Py_global_strings__bindgen_ty_2__bindgen_ty_633, pub _py_signed: _Py_global_strings__bindgen_ty_2__bindgen_ty_634, pub _py_size: _Py_global_strings__bindgen_ty_2__bindgen_ty_635, pub _py_sizehint: _Py_global_strings__bindgen_ty_2__bindgen_ty_636, pub _py_skip_file_prefixes: _Py_global_strings__bindgen_ty_2__bindgen_ty_637, pub _py_sleep: _Py_global_strings__bindgen_ty_2__bindgen_ty_638, pub _py_sock: _Py_global_strings__bindgen_ty_2__bindgen_ty_639, pub _py_sort: _Py_global_strings__bindgen_ty_2__bindgen_ty_640, pub _py_source: _Py_global_strings__bindgen_ty_2__bindgen_ty_641, pub _py_source_traceback: _Py_global_strings__bindgen_ty_2__bindgen_ty_642, pub _py_spam: _Py_global_strings__bindgen_ty_2__bindgen_ty_643, pub _py_src: _Py_global_strings__bindgen_ty_2__bindgen_ty_644, pub _py_src_dir_fd: _Py_global_strings__bindgen_ty_2__bindgen_ty_645, pub _py_stacklevel: _Py_global_strings__bindgen_ty_2__bindgen_ty_646, pub _py_start: _Py_global_strings__bindgen_ty_2__bindgen_ty_647, pub _py_statement: _Py_global_strings__bindgen_ty_2__bindgen_ty_648, pub _py_status: _Py_global_strings__bindgen_ty_2__bindgen_ty_649, pub _py_stderr: _Py_global_strings__bindgen_ty_2__bindgen_ty_650, pub _py_stdin: _Py_global_strings__bindgen_ty_2__bindgen_ty_651, pub _py_stdout: _Py_global_strings__bindgen_ty_2__bindgen_ty_652, pub _py_step: _Py_global_strings__bindgen_ty_2__bindgen_ty_653, pub _py_steps: _Py_global_strings__bindgen_ty_2__bindgen_ty_654, pub _py_store_name: _Py_global_strings__bindgen_ty_2__bindgen_ty_655, pub _py_strategy: _Py_global_strings__bindgen_ty_2__bindgen_ty_656, pub _py_strftime: _Py_global_strings__bindgen_ty_2__bindgen_ty_657, pub _py_strict: _Py_global_strings__bindgen_ty_2__bindgen_ty_658, pub _py_strict_mode: _Py_global_strings__bindgen_ty_2__bindgen_ty_659, pub _py_string: _Py_global_strings__bindgen_ty_2__bindgen_ty_660, pub _py_sub_key: _Py_global_strings__bindgen_ty_2__bindgen_ty_661, pub _py_symmetric_difference_update: _Py_global_strings__bindgen_ty_2__bindgen_ty_662, pub _py_tabsize: _Py_global_strings__bindgen_ty_2__bindgen_ty_663, pub _py_tag: _Py_global_strings__bindgen_ty_2__bindgen_ty_664, pub _py_target: _Py_global_strings__bindgen_ty_2__bindgen_ty_665, pub _py_target_is_directory: _Py_global_strings__bindgen_ty_2__bindgen_ty_666, pub _py_task: _Py_global_strings__bindgen_ty_2__bindgen_ty_667, pub _py_tb_frame: _Py_global_strings__bindgen_ty_2__bindgen_ty_668, pub _py_tb_lasti: _Py_global_strings__bindgen_ty_2__bindgen_ty_669, pub _py_tb_lineno: _Py_global_strings__bindgen_ty_2__bindgen_ty_670, pub _py_tb_next: _Py_global_strings__bindgen_ty_2__bindgen_ty_671, pub _py_tell: _Py_global_strings__bindgen_ty_2__bindgen_ty_672, pub _py_template: _Py_global_strings__bindgen_ty_2__bindgen_ty_673, pub _py_term: _Py_global_strings__bindgen_ty_2__bindgen_ty_674, pub _py_text: _Py_global_strings__bindgen_ty_2__bindgen_ty_675, pub _py_threading: _Py_global_strings__bindgen_ty_2__bindgen_ty_676, pub _py_throw: _Py_global_strings__bindgen_ty_2__bindgen_ty_677, pub _py_timeout: _Py_global_strings__bindgen_ty_2__bindgen_ty_678, pub _py_times: _Py_global_strings__bindgen_ty_2__bindgen_ty_679, pub _py_timetuple: _Py_global_strings__bindgen_ty_2__bindgen_ty_680, pub _py_top: _Py_global_strings__bindgen_ty_2__bindgen_ty_681, pub _py_trace_callback: _Py_global_strings__bindgen_ty_2__bindgen_ty_682, pub _py_traceback: _Py_global_strings__bindgen_ty_2__bindgen_ty_683, pub _py_trailers: _Py_global_strings__bindgen_ty_2__bindgen_ty_684, pub _py_translate: _Py_global_strings__bindgen_ty_2__bindgen_ty_685, pub _py_true: _Py_global_strings__bindgen_ty_2__bindgen_ty_686, pub _py_truncate: _Py_global_strings__bindgen_ty_2__bindgen_ty_687, pub _py_twice: _Py_global_strings__bindgen_ty_2__bindgen_ty_688, pub _py_txt: _Py_global_strings__bindgen_ty_2__bindgen_ty_689, pub _py_type: _Py_global_strings__bindgen_ty_2__bindgen_ty_690, pub _py_type_params: _Py_global_strings__bindgen_ty_2__bindgen_ty_691, pub _py_tz: _Py_global_strings__bindgen_ty_2__bindgen_ty_692, pub _py_tzinfo: _Py_global_strings__bindgen_ty_2__bindgen_ty_693, pub _py_tzname: _Py_global_strings__bindgen_ty_2__bindgen_ty_694, pub _py_uid: _Py_global_strings__bindgen_ty_2__bindgen_ty_695, pub _py_unlink: _Py_global_strings__bindgen_ty_2__bindgen_ty_696, pub _py_unraisablehook: _Py_global_strings__bindgen_ty_2__bindgen_ty_697, pub _py_uri: _Py_global_strings__bindgen_ty_2__bindgen_ty_698, pub _py_usedforsecurity: _Py_global_strings__bindgen_ty_2__bindgen_ty_699, pub _py_value: _Py_global_strings__bindgen_ty_2__bindgen_ty_700, pub _py_values: _Py_global_strings__bindgen_ty_2__bindgen_ty_701, pub _py_version: _Py_global_strings__bindgen_ty_2__bindgen_ty_702, pub _py_volume: _Py_global_strings__bindgen_ty_2__bindgen_ty_703, pub _py_wait_all: _Py_global_strings__bindgen_ty_2__bindgen_ty_704, pub _py_warn_on_full_buffer: _Py_global_strings__bindgen_ty_2__bindgen_ty_705, pub _py_warnings: _Py_global_strings__bindgen_ty_2__bindgen_ty_706, pub _py_warnoptions: _Py_global_strings__bindgen_ty_2__bindgen_ty_707, pub _py_wbits: _Py_global_strings__bindgen_ty_2__bindgen_ty_708, pub _py_week: _Py_global_strings__bindgen_ty_2__bindgen_ty_709, pub _py_weekday: _Py_global_strings__bindgen_ty_2__bindgen_ty_710, pub _py_which: _Py_global_strings__bindgen_ty_2__bindgen_ty_711, pub _py_who: _Py_global_strings__bindgen_ty_2__bindgen_ty_712, pub _py_withdata: _Py_global_strings__bindgen_ty_2__bindgen_ty_713, pub _py_writable: _Py_global_strings__bindgen_ty_2__bindgen_ty_714, pub _py_write: _Py_global_strings__bindgen_ty_2__bindgen_ty_715, pub _py_write_through: _Py_global_strings__bindgen_ty_2__bindgen_ty_716, pub _py_year: _Py_global_strings__bindgen_ty_2__bindgen_ty_717, pub _py_zdict: _Py_global_strings__bindgen_ty_2__bindgen_ty_718, } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_1 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_2 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_2 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_3 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_3 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_4 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_4 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_5 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_5 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_6 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_6 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_7 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_7 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_8 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_8 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_9 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_9 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_10 { pub _ascii: PyASCIIObject, pub _data: [u8; 18usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_10 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_11 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_11 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_12 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_12 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_13 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_13 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_14 { pub _ascii: PyASCIIObject, pub _data: [u8; 20usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_14 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_15 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_15 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_16 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_16 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_17 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_17 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_18 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_18 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_19 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_19 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_20 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_20 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_21 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_21 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_22 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_22 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_23 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_23 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_24 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_24 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_25 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_25 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_26 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_26 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_27 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_27 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_28 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_28 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_29 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_29 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_30 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_30 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_31 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_31 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_32 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_32 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_33 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_33 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_34 { pub _ascii: PyASCIIObject, pub _data: [u8; 18usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_34 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_35 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_35 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_36 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_36 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_37 { pub _ascii: PyASCIIObject, pub _data: [u8; 18usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_37 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_38 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_38 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_39 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_39 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_40 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_40 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_41 { pub _ascii: PyASCIIObject, pub _data: [u8; 25usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_41 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_42 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_42 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_43 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_43 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_44 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_44 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_45 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_45 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_46 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_46 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_47 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_47 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_48 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_48 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_49 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_49 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_50 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_50 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_51 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_51 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_52 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_52 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_53 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_53 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_54 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_54 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_55 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_55 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_56 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_56 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_57 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_57 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_58 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_58 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_59 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_59 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_60 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_60 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_61 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_61 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_62 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_62 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_63 { pub _ascii: PyASCIIObject, pub _data: [u8; 17usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_63 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_64 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_64 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_65 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_65 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_66 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_66 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_67 { pub _ascii: PyASCIIObject, pub _data: [u8; 18usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_67 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_68 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_68 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_69 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_69 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_70 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_70 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_71 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_71 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_72 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_72 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_73 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_73 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_74 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_74 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_75 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_75 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_76 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_76 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_77 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_77 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_78 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_78 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_79 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_79 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_80 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_80 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_81 { pub _ascii: PyASCIIObject, pub _data: [u8; 18usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_81 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_82 { pub _ascii: PyASCIIObject, pub _data: [u8; 18usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_82 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_83 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_83 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_84 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_84 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_85 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_85 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_86 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_86 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_87 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_87 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_88 { pub _ascii: PyASCIIObject, pub _data: [u8; 21usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_88 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_89 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_89 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_90 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_90 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_91 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_91 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_92 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_92 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_93 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_93 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_94 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_94 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_95 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_95 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_96 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_96 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_97 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_97 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_98 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_98 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_99 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_99 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_100 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_100 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_101 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_101 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_102 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_102 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_103 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_103 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_104 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_104 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_105 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_105 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_106 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_106 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_107 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_107 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_108 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_108 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_109 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_109 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_110 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_110 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_111 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_111 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_112 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_112 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_113 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_113 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_114 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_114 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_115 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_115 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_116 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_116 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_117 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_117 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_118 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_118 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_119 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_119 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_120 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_120 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_121 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_121 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_122 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_122 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_123 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_123 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_124 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_124 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_125 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_125 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_126 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_126 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_127 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_127 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_128 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_128 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_129 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_129 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_130 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_130 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_131 { pub _ascii: PyASCIIObject, pub _data: [u8; 19usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_131 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_132 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_132 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_133 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_133 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_134 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_134 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_135 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_135 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_136 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_136 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_137 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_137 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_138 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_138 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_139 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_139 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_140 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_140 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_141 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_141 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_142 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_142 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_143 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_143 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_144 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_144 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_145 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_145 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_146 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_146 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_147 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_147 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_148 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_148 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_149 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_149 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_150 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_150 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_151 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_151 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_152 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_152 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_153 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_153 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_154 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_154 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_155 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_155 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_156 { pub _ascii: PyASCIIObject, pub _data: [u8; 22usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_156 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_157 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_157 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_158 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_158 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_159 { pub _ascii: PyASCIIObject, pub _data: [u8; 18usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_159 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_160 { pub _ascii: PyASCIIObject, pub _data: [u8; 17usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_160 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_161 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_161 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_162 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_162 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_163 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_163 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_164 { pub _ascii: PyASCIIObject, pub _data: [u8; 36usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_164 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_165 { pub _ascii: PyASCIIObject, pub _data: [u8; 25usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_165 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_166 { pub _ascii: PyASCIIObject, pub _data: [u8; 17usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_166 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_167 { pub _ascii: PyASCIIObject, pub _data: [u8; 31usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_167 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_168 { pub _ascii: PyASCIIObject, pub _data: [u8; 20usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_168 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_169 { pub _ascii: PyASCIIObject, pub _data: [u8; 19usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_169 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_170 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_170 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_171 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_171 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_172 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_172 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_173 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_173 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_174 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_174 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_175 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_175 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_176 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_176 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_177 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_177 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_178 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_178 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_179 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_179 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_180 { pub _ascii: PyASCIIObject, pub _data: [u8; 25usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_180 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_181 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_181 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_182 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_182 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_183 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_183 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_184 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_184 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_185 { pub _ascii: PyASCIIObject, pub _data: [u8; 17usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_185 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_186 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_186 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_187 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_187 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_188 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_188 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_189 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_189 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_190 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_190 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_191 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_191 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_192 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_192 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_193 { pub _ascii: PyASCIIObject, pub _data: [u8; 17usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_193 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_194 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_194 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_195 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_195 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_196 { pub _ascii: PyASCIIObject, pub _data: [u8; 18usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_196 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_197 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_197 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_198 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_198 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_199 { pub _ascii: PyASCIIObject, pub _data: [u8; 20usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_199 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_200 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_200 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_201 { pub _ascii: PyASCIIObject, pub _data: [u8; 19usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_201 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_202 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_202 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_203 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_203 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_204 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_204 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_205 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_205 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_206 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_206 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_207 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_207 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_208 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_208 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_209 { pub _ascii: PyASCIIObject, pub _data: [u8; 19usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_209 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_210 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_210 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_211 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_211 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_212 { pub _ascii: PyASCIIObject, pub _data: [u8; 26usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_212 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_213 { pub _ascii: PyASCIIObject, pub _data: [u8; 26usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_213 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_214 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_214 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_215 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_215 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_216 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_216 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_217 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_217 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_218 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_218 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_219 { pub _ascii: PyASCIIObject, pub _data: [u8; 18usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_219 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_220 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_220 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_221 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_221 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_222 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_222 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_223 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_223 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_224 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_224 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_225 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_225 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_226 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_226 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_227 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_227 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_228 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_228 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_229 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_229 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_230 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_230 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_231 { pub _ascii: PyASCIIObject, pub _data: [u8; 17usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_231 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_232 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_232 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_233 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_233 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_234 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_234 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_235 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_235 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_236 { pub _ascii: PyASCIIObject, pub _data: [u8; 20usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_236 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_237 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_237 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_238 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_238 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_239 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_239 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_240 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_240 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_241 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_241 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_242 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_242 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_243 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_243 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_244 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_244 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_245 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_245 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_246 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_246 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_247 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_247 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_248 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_248 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_249 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_249 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_250 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_250 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_251 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_251 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_252 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_252 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_253 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_253 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_254 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_254 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_255 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_255 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_256 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_256 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_257 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_257 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_258 { pub _ascii: PyASCIIObject, pub _data: [u8; 23usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_258 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_259 { pub _ascii: PyASCIIObject, pub _data: [u8; 18usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_259 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_260 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_260 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_261 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_261 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_262 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_262 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_263 { pub _ascii: PyASCIIObject, pub _data: [u8; 23usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_263 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_264 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_264 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_265 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_265 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_266 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_266 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_267 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_267 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_268 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_268 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_269 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_269 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_270 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_270 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_271 { pub _ascii: PyASCIIObject, pub _data: [u8; 18usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_271 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_272 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_272 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_273 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_273 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_274 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_274 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_275 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_275 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_276 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_276 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_277 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_277 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_278 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_278 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_279 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_279 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_280 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_280 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_281 { pub _ascii: PyASCIIObject, pub _data: [u8; 18usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_281 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_282 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_282 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_283 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_283 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_284 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_284 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_285 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_285 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_286 { pub _ascii: PyASCIIObject, pub _data: [u8; 18usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_286 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_287 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_287 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_288 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_288 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_289 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_289 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_290 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_290 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_291 { pub _ascii: PyASCIIObject, pub _data: [u8; 19usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_291 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_292 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_292 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_293 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_293 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_294 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_294 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_295 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_295 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_296 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_296 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_297 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_297 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_298 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_298 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_299 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_299 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_300 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_300 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_301 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_301 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_302 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_302 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_303 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_303 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_304 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_304 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_305 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_305 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_306 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_306 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_307 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_307 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_308 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_308 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_309 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_309 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_310 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_310 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_311 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_311 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_312 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_312 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_313 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_313 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_314 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_314 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_315 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_315 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_316 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_316 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_317 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_317 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_318 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_318 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_319 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_319 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_320 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_320 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_321 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_321 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_322 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_322 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_323 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_323 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_324 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_324 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_325 { pub _ascii: PyASCIIObject, pub _data: [u8; 18usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_325 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_326 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_326 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_327 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_327 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_328 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_328 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_329 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_329 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_330 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_330 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_331 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_331 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_332 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_332 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_333 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_333 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_334 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_334 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_335 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_335 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_336 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_336 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_337 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_337 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_338 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_338 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_339 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_339 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_340 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_340 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_341 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_341 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_342 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_342 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_343 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_343 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_344 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_344 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_345 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_345 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_346 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_346 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_347 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_347 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_348 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_348 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_349 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_349 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_350 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_350 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_351 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_351 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_352 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_352 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_353 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_353 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_354 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_354 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_355 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_355 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_356 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_356 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_357 { pub _ascii: PyASCIIObject, pub _data: [u8; 19usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_357 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_358 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_358 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_359 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_359 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_360 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_360 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_361 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_361 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_362 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_362 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_363 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_363 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_364 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_364 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_365 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_365 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_366 { pub _ascii: PyASCIIObject, pub _data: [u8; 3usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_366 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_367 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_367 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_368 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_368 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_369 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_369 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_370 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_370 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_371 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_371 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_372 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_372 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_373 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_373 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_374 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_374 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_375 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_375 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_376 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_376 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_377 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_377 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_378 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_378 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_379 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_379 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_380 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_380 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_381 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_381 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_382 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_382 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_383 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_383 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_384 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_384 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_385 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_385 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_386 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_386 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_387 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_387 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_388 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_388 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_389 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_389 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_390 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_390 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_391 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_391 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_392 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_392 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_393 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_393 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_394 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_394 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_395 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_395 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_396 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_396 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_397 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_397 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_398 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_398 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_399 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_399 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_400 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_400 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_401 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_401 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_402 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_402 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_403 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_403 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_404 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_404 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_405 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_405 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_406 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_406 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_407 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_407 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_408 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_408 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_409 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_409 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_410 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_410 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_411 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_411 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_412 { pub _ascii: PyASCIIObject, pub _data: [u8; 3usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_412 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_413 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_413 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_414 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_414 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_415 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_415 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_416 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_416 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_417 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_417 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_418 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_418 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_419 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_419 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_420 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_420 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_421 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_421 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_422 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_422 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_423 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_423 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_424 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_424 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_425 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_425 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_426 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_426 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_427 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_427 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_428 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_428 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_429 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_429 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_430 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_430 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_431 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_431 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_432 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_432 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_433 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_433 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_434 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_434 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_435 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_435 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_436 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_436 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_437 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_437 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_438 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_438 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_439 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_439 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_440 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_440 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_441 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_441 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_442 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_442 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_443 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_443 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_444 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_444 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_445 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_445 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_446 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_446 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_447 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_447 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_448 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_448 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_449 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_449 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_450 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_450 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_451 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_451 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_452 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_452 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_453 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_453 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_454 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_454 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_455 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_455 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_456 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_456 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_457 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_457 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_458 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_458 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_459 { pub _ascii: PyASCIIObject, pub _data: [u8; 3usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_459 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_460 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_460 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_461 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_461 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_462 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_462 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_463 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_463 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_464 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_464 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_465 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_465 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_466 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_466 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_467 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_467 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_468 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_468 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_469 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_469 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_470 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_470 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_471 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_471 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_472 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_472 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_473 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_473 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_474 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_474 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_475 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_475 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_476 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_476 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_477 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_477 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_478 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_478 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_479 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_479 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_480 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_480 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_481 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_481 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_482 { pub _ascii: PyASCIIObject, pub _data: [u8; 3usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_482 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_483 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_483 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_484 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_484 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_485 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_485 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_486 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_486 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_487 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_487 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_488 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_488 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_489 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_489 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_490 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_490 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_491 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_491 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_492 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_492 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_493 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_493 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_494 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_494 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_495 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_495 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_496 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_496 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_497 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_497 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_498 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_498 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_499 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_499 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_500 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_500 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_501 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_501 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_502 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_502 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_503 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_503 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_504 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_504 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_505 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_505 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_506 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_506 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_507 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_507 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_508 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_508 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_509 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_509 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_510 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_510 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_511 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_511 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_512 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_512 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_513 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_513 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_514 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_514 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_515 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_515 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_516 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_516 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_517 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_517 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_518 { pub _ascii: PyASCIIObject, pub _data: [u8; 18usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_518 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_519 { pub _ascii: PyASCIIObject, pub _data: [u8; 17usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_519 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_520 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_520 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_521 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_521 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_522 { pub _ascii: PyASCIIObject, pub _data: [u8; 20usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_522 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_523 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_523 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_524 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_524 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_525 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_525 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_526 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_526 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_527 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_527 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_528 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_528 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_529 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_529 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_530 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_530 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_531 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_531 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_532 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_532 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_533 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_533 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_534 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_534 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_535 { pub _ascii: PyASCIIObject, pub _data: [u8; 3usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_535 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_536 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_536 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_537 { pub _ascii: PyASCIIObject, pub _data: [u8; 3usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_537 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_538 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_538 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_539 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_539 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_540 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_540 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_541 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_541 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_542 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_542 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_543 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_543 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_544 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_544 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_545 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_545 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_546 { pub _ascii: PyASCIIObject, pub _data: [u8; 13usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_546 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_547 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_547 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_548 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_548 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_549 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_549 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_550 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_550 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_551 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_551 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_552 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_552 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_553 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_553 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_554 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_554 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_555 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_555 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_556 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_556 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_557 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_557 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_558 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_558 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_559 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_559 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_560 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_560 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_561 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_561 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_562 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_562 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_563 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_563 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_564 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_564 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_565 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_565 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_566 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_566 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_567 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_567 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_568 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_568 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_569 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_569 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_570 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_570 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_571 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_571 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_572 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_572 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_573 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_573 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_574 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_574 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_575 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_575 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_576 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_576 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_577 { pub _ascii: PyASCIIObject, pub _data: [u8; 20usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_577 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_578 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_578 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_579 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_579 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_580 { pub _ascii: PyASCIIObject, pub _data: [u8; 17usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_580 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_581 { pub _ascii: PyASCIIObject, pub _data: [u8; 17usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_581 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_582 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_582 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_583 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_583 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_584 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_584 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_585 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_585 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_586 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_586 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_587 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_587 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_588 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_588 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_589 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_589 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_590 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_590 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_591 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_591 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_592 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_592 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_593 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_593 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_594 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_594 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_595 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_595 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_596 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_596 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_597 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_597 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_598 { pub _ascii: PyASCIIObject, pub _data: [u8; 17usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_598 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_599 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_599 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_600 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_600 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_601 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_601 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_602 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_602 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_603 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_603 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_604 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_604 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_605 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_605 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_606 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_606 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_607 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_607 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_608 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_608 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_609 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_609 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_610 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_610 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_611 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_611 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_612 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_612 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_613 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_613 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_614 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_614 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_615 { pub _ascii: PyASCIIObject, pub _data: [u8; 20usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_615 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_616 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_616 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_617 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_617 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_618 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_618 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_619 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_619 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_620 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_620 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_621 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_621 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_622 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_622 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_623 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_623 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_624 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_624 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_625 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_625 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_626 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_626 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_627 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_627 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_628 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_628 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_629 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_629 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_630 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_630 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_631 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_631 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_632 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_632 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_633 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_633 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_634 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_634 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_635 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_635 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_636 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_636 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_637 { pub _ascii: PyASCIIObject, pub _data: [u8; 19usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_637 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_638 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_638 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_639 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_639 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_640 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_640 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_641 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_641 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_642 { pub _ascii: PyASCIIObject, pub _data: [u8; 17usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_642 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_643 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_643 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_644 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_644 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_645 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_645 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_646 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_646 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_647 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_647 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_648 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_648 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_649 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_649 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_650 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_650 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_651 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_651 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_652 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_652 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_653 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_653 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_654 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_654 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_655 { pub _ascii: PyASCIIObject, pub _data: [u8; 11usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_655 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_656 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_656 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_657 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_657 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_658 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_658 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_659 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_659 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_660 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_660 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_661 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_661 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_662 { pub _ascii: PyASCIIObject, pub _data: [u8; 28usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_662 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_663 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_663 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_664 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_664 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_665 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_665 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_666 { pub _ascii: PyASCIIObject, pub _data: [u8; 20usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_666 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_667 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_667 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_668 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_668 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_669 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_669 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_670 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_670 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_671 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_671 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_672 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_672 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_673 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_673 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_674 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_674 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_675 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_675 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_676 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_676 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_677 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_677 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_678 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_678 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_679 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_679 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_680 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_680 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_681 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_681 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_682 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_682 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_683 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_683 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_684 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_684 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_685 { pub _ascii: PyASCIIObject, pub _data: [u8; 10usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_685 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_686 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_686 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_687 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_687 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_688 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_688 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_689 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_689 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_690 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_690 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_691 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_691 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_692 { pub _ascii: PyASCIIObject, pub _data: [u8; 3usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_692 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_693 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_693 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_694 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_694 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_695 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_695 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_696 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_696 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_697 { pub _ascii: PyASCIIObject, pub _data: [u8; 15usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_697 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_698 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_698 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_699 { pub _ascii: PyASCIIObject, pub _data: [u8; 16usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_699 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_700 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_700 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_701 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_701 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_702 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_702 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_703 { pub _ascii: PyASCIIObject, pub _data: [u8; 7usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_703 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_704 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_704 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_705 { pub _ascii: PyASCIIObject, pub _data: [u8; 20usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_705 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_706 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_706 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_707 { pub _ascii: PyASCIIObject, pub _data: [u8; 12usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_707 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_708 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_708 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_709 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_709 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_710 { pub _ascii: PyASCIIObject, pub _data: [u8; 8usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_710 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_711 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_711 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_712 { pub _ascii: PyASCIIObject, pub _data: [u8; 4usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_712 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_713 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_713 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_714 { pub _ascii: PyASCIIObject, pub _data: [u8; 9usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_714 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_715 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_715 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_716 { pub _ascii: PyASCIIObject, pub _data: [u8; 14usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_716 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_717 { pub _ascii: PyASCIIObject, pub _data: [u8; 5usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_717 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_718 { pub _ascii: PyASCIIObject, pub _data: [u8; 6usize], } impl Default for _Py_global_strings__bindgen_ty_2__bindgen_ty_718 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for _Py_global_strings__bindgen_ty_2 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_3 { pub _ascii: PyASCIIObject, pub _data: [u8; 2usize], } impl Default for _Py_global_strings__bindgen_ty_3 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_global_strings__bindgen_ty_4 { pub _latin1: PyCompactUnicodeObject, pub _data: [u8; 2usize], } impl Default for _Py_global_strings__bindgen_ty_4 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for _Py_global_strings { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_slist_item_s { pub next: *mut _Py_slist_item_s, } impl Default for _Py_slist_item_s { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type _Py_slist_item_t = _Py_slist_item_s; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_slist_t { pub head: *mut _Py_slist_item_t, } impl Default for _Py_slist_t { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_hashtable_entry_t { pub _Py_slist_item: _Py_slist_item_t, pub key_hash: Py_uhash_t, pub key: *mut ::std::os::raw::c_void, pub value: *mut ::std::os::raw::c_void, } impl Default for _Py_hashtable_entry_t { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type _Py_hashtable_hash_func = ::std::option::Option Py_uhash_t>; pub type _Py_hashtable_compare_func = ::std::option::Option< unsafe extern "C" fn( key1: *const ::std::os::raw::c_void, key2: *const ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; pub type _Py_hashtable_destroy_func = ::std::option::Option; pub type _Py_hashtable_get_entry_func = ::std::option::Option< unsafe extern "C" fn( ht: *mut _Py_hashtable_t, key: *const ::std::os::raw::c_void, ) -> *mut _Py_hashtable_entry_t, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_hashtable_allocator_t { pub malloc: ::std::option::Option *mut ::std::os::raw::c_void>, pub free: ::std::option::Option, } impl Default for _Py_hashtable_allocator_t { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_hashtable_t { pub nentries: usize, pub nbuckets: usize, pub buckets: *mut _Py_slist_t, pub get_entry_func: _Py_hashtable_get_entry_func, pub hash_func: _Py_hashtable_hash_func, pub compare_func: _Py_hashtable_compare_func, pub key_destroy_func: _Py_hashtable_destroy_func, pub value_destroy_func: _Py_hashtable_destroy_func, pub alloc: _Py_hashtable_allocator_t, } impl Default for _Py_hashtable_t { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _types_runtime_state { pub next_version_tag: ::std::os::raw::c_uint, pub managed_static: _types_runtime_state__bindgen_ty_1, } #[repr(C)] #[derive(Copy, Clone)] pub struct _types_runtime_state__bindgen_ty_1 { pub types: [_types_runtime_state__bindgen_ty_1__bindgen_ty_1; 210usize], } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _types_runtime_state__bindgen_ty_1__bindgen_ty_1 { pub type_: *mut PyTypeObject, pub interp_count: i64, } impl Default for _types_runtime_state__bindgen_ty_1__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for _types_runtime_state__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for _types_runtime_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct type_cache_entry { pub version: ::std::os::raw::c_uint, pub name: *mut PyObject, pub value: *mut PyObject, } impl Default for type_cache_entry { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct type_cache { pub hashtable: [type_cache_entry; 4096usize], } impl Default for type_cache { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct managed_static_type_state { pub type_: *mut PyTypeObject, pub isbuiltin: ::std::os::raw::c_int, pub readying: ::std::os::raw::c_int, pub ready: ::std::os::raw::c_int, pub tp_dict: *mut PyObject, pub tp_subclasses: *mut PyObject, pub tp_weaklist: *mut PyObject, } impl Default for managed_static_type_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct types_state { pub next_version_tag: ::std::os::raw::c_uint, pub type_cache: type_cache, pub builtins: types_state__bindgen_ty_1, pub for_extensions: types_state__bindgen_ty_2, pub mutex: PyMutex, } #[repr(C)] #[derive(Copy, Clone)] pub struct types_state__bindgen_ty_1 { pub num_initialized: usize, pub initialized: [managed_static_type_state; 200usize], } impl Default for types_state__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct types_state__bindgen_ty_2 { pub num_initialized: usize, pub next_index: usize, pub initialized: [managed_static_type_state; 10usize], } impl Default for types_state__bindgen_ty_2 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for types_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type pytype_slotdef = wrapperbase; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_cached_objects { pub interned_strings: *mut _Py_hashtable_t, } impl Default for _Py_cached_objects { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_static_objects { pub singletons: _Py_static_objects__bindgen_ty_1, } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_static_objects__bindgen_ty_1 { pub small_ints: [PyLongObject; 262usize], pub bytes_empty: PyBytesObject, pub bytes_characters: [_Py_static_objects__bindgen_ty_1__bindgen_ty_1; 256usize], pub strings: _Py_global_strings, pub _tuple_empty_gc_not_used: PyGC_Head, pub tuple_empty: PyTupleObject, pub _hamt_bitmap_node_empty_gc_not_used: PyGC_Head, pub hamt_bitmap_node_empty: PyHamtNode_Bitmap, pub context_token_missing: _PyContextTokenMissing, } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_static_objects__bindgen_ty_1__bindgen_ty_1 { pub ob: PyBytesObject, pub eos: ::std::os::raw::c_char, } impl Default for _Py_static_objects__bindgen_ty_1__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for _Py_static_objects__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for _Py_static_objects { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_interp_cached_objects { pub interned_strings: *mut PyObject, pub str_replace_inf: *mut PyObject, pub objreduce: *mut PyObject, pub type_slots_pname: *mut PyObject, pub type_slots_ptrs: [*mut pytype_slotdef; 10usize], pub generic_type: *mut PyTypeObject, pub typevar_type: *mut PyTypeObject, pub typevartuple_type: *mut PyTypeObject, pub paramspec_type: *mut PyTypeObject, pub paramspecargs_type: *mut PyTypeObject, pub paramspeckwargs_type: *mut PyTypeObject, } impl Default for _Py_interp_cached_objects { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_interp_static_objects { pub singletons: _Py_interp_static_objects__bindgen_ty_1, } #[repr(C)] #[derive(Copy, Clone)] pub struct _Py_interp_static_objects__bindgen_ty_1 { pub _not_used: ::std::os::raw::c_int, pub _hamt_empty_gc_not_used: PyGC_Head, pub hamt_empty: PyHamtObject, pub last_resort_memory_error: PyBaseExceptionObject, } impl Default for _Py_interp_static_objects__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for _Py_interp_static_objects { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_unicode_runtime_ids { pub mutex: PyMutex, pub next_index: Py_ssize_t, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_unicode_runtime_state { pub ids: _Py_unicode_runtime_ids, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_unicode_fs_codec { pub encoding: *mut ::std::os::raw::c_char, pub utf8: ::std::os::raw::c_int, pub errors: *mut ::std::os::raw::c_char, pub error_handler: _Py_error_handler, } impl Default for _Py_unicode_fs_codec { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_unicode_ids { pub size: Py_ssize_t, pub array: *mut *mut PyObject, } impl Default for _Py_unicode_ids { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_unicode_state { pub fs_codec: _Py_unicode_fs_codec, pub ucnhash_capi: *mut _PyUnicode_Name_CAPI, pub ids: _Py_unicode_ids, } impl Default for _Py_unicode_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub const _py_float_format_type__py_float_format_unknown: _py_float_format_type = 0; pub const _py_float_format_type__py_float_format_ieee_big_endian: _py_float_format_type = 1; pub const _py_float_format_type__py_float_format_ieee_little_endian: _py_float_format_type = 2; pub type _py_float_format_type = u32; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_float_runtime_state { pub float_format: _py_float_format_type, pub double_format: _py_float_format_type, } impl Default for _Py_float_runtime_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _func_version_cache_item { pub func: *mut PyFunctionObject, pub code: *mut PyObject, } impl Default for _func_version_cache_item { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _py_func_state { pub next_version: u32, pub func_version_cache: [_func_version_cache_item; 4096usize], } impl Default for _py_func_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _import_runtime_state { pub inittab: *mut _inittab, pub last_module_index: Py_ssize_t, pub extensions: _import_runtime_state__bindgen_ty_1, pub pkgcontext: *const ::std::os::raw::c_char, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _import_runtime_state__bindgen_ty_1 { pub mutex: PyMutex, pub hashtable: *mut _Py_hashtable_t, } impl Default for _import_runtime_state__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for _import_runtime_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _import_state { pub modules: *mut PyObject, pub modules_by_index: *mut PyObject, pub importlib: *mut PyObject, pub override_frozen_modules: ::std::os::raw::c_int, pub override_multi_interp_extensions_check: ::std::os::raw::c_int, pub dlopenflags: ::std::os::raw::c_int, pub import_func: *mut PyObject, pub lock: _PyRecursiveMutex, pub find_and_load: _import_state__bindgen_ty_1, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _import_state__bindgen_ty_1 { pub import_level: ::std::os::raw::c_int, pub accumulated: PyTime_t, pub header: ::std::os::raw::c_int, } impl Default for _import_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _frame { pub ob_base: PyObject, pub f_back: *mut PyFrameObject, pub f_frame: *mut _PyInterpreterFrame, pub f_trace: *mut PyObject, pub f_lineno: ::std::os::raw::c_int, pub f_trace_lines: ::std::os::raw::c_char, pub f_trace_opcodes: ::std::os::raw::c_char, pub f_extra_locals: *mut PyObject, pub f_locals_cache: *mut PyObject, pub _f_frame_data: [*mut PyObject; 1usize], } impl Default for _frame { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _PyInterpreterFrame { pub f_executable: *mut PyObject, pub previous: *mut _PyInterpreterFrame, pub f_funcobj: *mut PyObject, pub f_globals: *mut PyObject, pub f_builtins: *mut PyObject, pub f_locals: *mut PyObject, pub frame_obj: *mut PyFrameObject, pub instr_ptr: *mut _Py_CODEUNIT, pub stacktop: ::std::os::raw::c_int, pub return_offset: u16, pub owner: ::std::os::raw::c_char, pub localsplus: [*mut PyObject; 1usize], } impl Default for _PyInterpreterFrame { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct debug_alloc_api_t { pub api_id: ::std::os::raw::c_char, pub alloc: PyMemAllocatorEx, } impl Default for debug_alloc_api_t { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _pymem_allocators { pub mutex: PyMutex, pub standard: _pymem_allocators__bindgen_ty_1, pub debug: _pymem_allocators__bindgen_ty_2, pub is_debug_enabled: ::std::os::raw::c_int, pub obj_arena: PyObjectArenaAllocator, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _pymem_allocators__bindgen_ty_1 { pub raw: PyMemAllocatorEx, pub mem: PyMemAllocatorEx, pub obj: PyMemAllocatorEx, } impl Default for _pymem_allocators__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _pymem_allocators__bindgen_ty_2 { pub raw: debug_alloc_api_t, pub mem: debug_alloc_api_t, pub obj: debug_alloc_api_t, } impl Default for _pymem_allocators__bindgen_ty_2 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for _pymem_allocators { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_mem_interp_free_queue { pub has_work: ::std::os::raw::c_int, pub mutex: PyMutex, pub head: llist_node, } impl Default for _Py_mem_interp_free_queue { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _py_object_runtime_state { pub _not_used: ::std::os::raw::c_int, } #[repr(C)] #[derive(Copy, Clone)] pub struct _py_object_state { pub freelists: _Py_object_freelists, pub _not_used: ::std::os::raw::c_int, } impl Default for _py_object_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _PyExecutorLinkListNode { pub next: *mut _PyExecutorObject, pub previous: *mut _PyExecutorObject, } impl Default for _PyExecutorLinkListNode { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _bloom_filter { pub bits: [u32; 8usize], } pub type _PyBloomFilter = _bloom_filter; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _PyVMData { pub opcode: u8, pub oparg: u8, pub valid: u8, pub linked: u8, pub index: ::std::os::raw::c_int, pub bloom: _PyBloomFilter, pub links: _PyExecutorLinkListNode, pub code: *mut PyCodeObject, } impl Default for _PyVMData { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _PyUOpInstruction { pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u16>, pub oparg: u16, pub __bindgen_anon_1: _PyUOpInstruction__bindgen_ty_1, pub operand: u64, } #[repr(C)] #[derive(Copy, Clone)] pub union _PyUOpInstruction__bindgen_ty_1 { pub target: u32, pub __bindgen_anon_1: _PyUOpInstruction__bindgen_ty_1__bindgen_ty_1, _bindgen_union_align: u32, } #[repr(C)] #[derive(Copy, Clone)] pub struct _PyUOpInstruction__bindgen_ty_1__bindgen_ty_1 { pub __bindgen_anon_1: _PyUOpInstruction__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1, pub error_target: u16, } #[repr(C)] #[derive(Copy, Clone)] pub union _PyUOpInstruction__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 { pub exit_index: u16, pub jump_target: u16, _bindgen_union_align: u16, } impl Default for _PyUOpInstruction__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for _PyUOpInstruction__bindgen_ty_1__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for _PyUOpInstruction__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for _PyUOpInstruction { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl _PyUOpInstruction { #[inline] pub fn opcode(&self) -> u16 { unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 14u8) as u16) } } #[inline] pub fn set_opcode(&mut self, val: u16) { unsafe { let val: u16 = ::std::mem::transmute(val); self._bitfield_1.set(0usize, 14u8, val as u64) } } #[inline] pub fn format(&self) -> u16 { unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 2u8) as u16) } } #[inline] pub fn set_format(&mut self, val: u16) { unsafe { let val: u16 = ::std::mem::transmute(val); self._bitfield_1.set(14usize, 2u8, val as u64) } } #[inline] pub fn new_bitfield_1(opcode: u16, format: u16) -> __BindgenBitfieldUnit<[u8; 2usize], u16> { let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u16> = Default::default(); __bindgen_bitfield_unit.set(0usize, 14u8, { let opcode: u16 = unsafe { ::std::mem::transmute(opcode) }; opcode as u64 }); __bindgen_bitfield_unit.set(14usize, 2u8, { let format: u16 = unsafe { ::std::mem::transmute(format) }; format as u64 }); __bindgen_bitfield_unit } } #[repr(C)] #[derive(Copy, Clone)] pub struct _exit_data { pub target: u32, pub temperature: _Py_BackoffCounter, pub executor: *const _PyExecutorObject, } impl Default for _exit_data { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type _PyExitData = _exit_data; #[repr(C)] #[derive(Copy, Clone)] pub struct _PyExecutorObject { pub ob_base: PyVarObject, pub trace: *const _PyUOpInstruction, pub vm_data: _PyVMData, pub exit_count: u32, pub code_size: u32, pub jit_size: usize, pub jit_code: *mut ::std::os::raw::c_void, pub jit_side_entry: *mut ::std::os::raw::c_void, pub exits: [_PyExitData; 1usize], } impl Default for _PyExecutorObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type optimize_func = ::std::option::Option< unsafe extern "C" fn( self_: *mut _PyOptimizerObject, frame: *mut _PyInterpreterFrame, instr: *mut _Py_CODEUNIT, exec_ptr: *mut *mut _PyExecutorObject, curr_stackentries: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Copy, Clone)] pub struct _PyOptimizerObject { pub ob_base: PyObject, pub optimize: optimize_func, } impl Default for _PyOptimizerObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type pymem_uint = ::std::os::raw::c_uint; pub type pymem_block = u8; #[repr(C)] #[derive(Copy, Clone)] pub struct pool_header { pub ref_: pool_header__bindgen_ty_1, pub freeblock: *mut pymem_block, pub nextpool: *mut pool_header, pub prevpool: *mut pool_header, pub arenaindex: pymem_uint, pub szidx: pymem_uint, pub nextoffset: pymem_uint, pub maxnextoffset: pymem_uint, } #[repr(C)] #[derive(Copy, Clone)] pub union pool_header__bindgen_ty_1 { pub _padding: *mut pymem_block, pub count: pymem_uint, _bindgen_union_align: u64, } impl Default for pool_header__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for pool_header { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type poolp = *mut pool_header; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct arena_object { pub address: usize, pub pool_address: *mut pymem_block, pub nfreepools: pymem_uint, pub ntotalpools: pymem_uint, pub freepools: *mut pool_header, pub nextarena: *mut arena_object, pub prevarena: *mut arena_object, } impl Default for arena_object { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _obmalloc_pools { pub used: [poolp; 64usize], } impl Default for _obmalloc_pools { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _obmalloc_mgmt { pub arenas: *mut arena_object, pub maxarenas: pymem_uint, pub unused_arena_objects: *mut arena_object, pub usable_arenas: *mut arena_object, pub nfp2lasta: [*mut arena_object; 65usize], pub narenas_currently_allocated: usize, pub ntimes_arena_allocated: usize, pub narenas_highwater: usize, pub raw_allocated_blocks: Py_ssize_t, } impl Default for _obmalloc_mgmt { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct arena_coverage_t { pub tail_hi: i32, pub tail_lo: i32, } #[repr(C)] #[derive(Copy, Clone)] pub struct arena_map_bot { pub arenas: [arena_coverage_t; 16384usize], } impl Default for arena_map_bot { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct arena_map_mid { pub ptrs: [*mut arena_map_bot; 32768usize], } impl Default for arena_map_mid { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct arena_map_top { pub ptrs: [*mut arena_map_mid; 32768usize], } impl Default for arena_map_top { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type arena_map_top_t = arena_map_top; #[repr(C)] #[derive(Copy, Clone)] pub struct _obmalloc_usage { pub arena_map_root: arena_map_top_t, pub arena_map_mid_count: ::std::os::raw::c_int, pub arena_map_bot_count: ::std::os::raw::c_int, } impl Default for _obmalloc_usage { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _obmalloc_global_state { pub dump_debug_stats: ::std::os::raw::c_int, pub interpreter_leaks: Py_ssize_t, } #[repr(C)] #[derive(Copy, Clone)] pub struct _obmalloc_state { pub pools: _obmalloc_pools, pub mgmt: _obmalloc_mgmt, pub usage: _obmalloc_usage, } impl Default for _obmalloc_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _qsbr_thread_state { pub seq: u64, pub shared: *mut _qsbr_shared, pub tstate: *mut PyThreadState, pub deferrals: ::std::os::raw::c_int, pub allocated: bool, pub freelist_next: *mut _qsbr_thread_state, } impl Default for _qsbr_thread_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _qsbr_pad { pub qsbr: _qsbr_thread_state, pub __padding: [::std::os::raw::c_char; 24usize], } impl Default for _qsbr_pad { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _qsbr_shared { pub wr_seq: u64, pub rd_seq: u64, pub array: *mut _qsbr_pad, pub size: Py_ssize_t, pub mutex: PyMutex, pub freelist: *mut _qsbr_thread_state, } impl Default for _qsbr_shared { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _PyObjectStackChunk { pub prev: *mut _PyObjectStackChunk, pub n: Py_ssize_t, pub objs: [*mut PyObject; 254usize], } impl Default for _PyObjectStackChunk { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _PyThreadStateImpl { pub base: PyThreadState, pub asyncio_running_loop: *mut PyObject, pub qsbr: *mut _qsbr_thread_state, pub mem_free_queue: llist_node, } impl Default for _PyThreadStateImpl { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _warnings_runtime_state { pub filters: *mut PyObject, pub once_registry: *mut PyObject, pub default_action: *mut PyObject, pub mutex: PyMutex, pub filters_version: ::std::os::raw::c_long, } impl Default for _warnings_runtime_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_long_state { pub max_str_digits: ::std::os::raw::c_int, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _stoptheworld_state { pub mutex: PyMutex, pub requested: bool, pub world_stopped: bool, pub is_global: bool, pub stop_event: PyEvent, pub thread_countdown: Py_ssize_t, pub requester: *mut PyThreadState, } impl Default for _stoptheworld_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _rare_events { pub set_class: u8, pub set_bases: u8, pub set_eval_frame_func: u8, pub builtin_dict: u8, pub func_modification: u8, } #[repr(C)] #[derive(Copy, Clone)] pub struct _is { pub ceval: _ceval_state, pub next: *mut PyInterpreterState, pub id: i64, pub id_refcount: i64, pub requires_idref: ::std::os::raw::c_int, pub id_mutex: PyThread_type_lock, pub _whence: ::std::os::raw::c_long, pub _initialized: ::std::os::raw::c_int, pub _ready: ::std::os::raw::c_int, pub finalizing: ::std::os::raw::c_int, pub last_restart_version: usize, pub threads: _is_pythreads, pub runtime: *mut pyruntimestate, pub _finalizing: *mut PyThreadState, pub _finalizing_id: ::std::os::raw::c_ulong, pub gc: _gc_runtime_state, pub sysdict: *mut PyObject, pub builtins: *mut PyObject, pub imports: _import_state, pub _gil: _gil_runtime_state, pub codecs: codecs_state, pub config: PyConfig, pub feature_flags: ::std::os::raw::c_ulong, pub dict: *mut PyObject, pub sysdict_copy: *mut PyObject, pub builtins_copy: *mut PyObject, pub eval_frame: _PyFrameEvalFunction, pub func_watchers: [PyFunction_WatchCallback; 8usize], pub active_func_watchers: u8, pub co_extra_user_count: Py_ssize_t, pub co_extra_freefuncs: [freefunc; 255usize], pub xi: _xi_state, pub before_forkers: *mut PyObject, pub after_forkers_parent: *mut PyObject, pub after_forkers_child: *mut PyObject, pub warnings: _warnings_runtime_state, pub atexit: atexit_state, pub stoptheworld: _stoptheworld_state, pub qsbr: _qsbr_shared, pub obmalloc: *mut _obmalloc_state, pub audit_hooks: *mut PyObject, pub type_watchers: [PyType_WatchCallback; 8usize], pub code_watchers: [PyCode_WatchCallback; 8usize], pub active_code_watchers: u8, pub object_state: _py_object_state, pub unicode: _Py_unicode_state, pub long_state: _Py_long_state, pub dtoa: _dtoa_state, pub func_state: _py_func_state, pub code_state: _py_code_state, pub dict_state: _Py_dict_state, pub exc_state: _Py_exc_state, pub mem_free_queue: _Py_mem_interp_free_queue, pub ast: ast_state, pub types: types_state, pub callable_cache: callable_cache, pub optimizer: *mut _PyOptimizerObject, pub executor_list_head: *mut _PyExecutorObject, pub rare_events: _rare_events, pub builtins_dict_watcher: PyDict_WatchCallback, pub monitors: _Py_GlobalMonitors, pub sys_profile_initialized: bool, pub sys_trace_initialized: bool, pub sys_profiling_threads: Py_ssize_t, pub sys_tracing_threads: Py_ssize_t, pub monitoring_callables: [[*mut PyObject; 17usize]; 8usize], pub monitoring_tool_names: [*mut PyObject; 8usize], pub cached_objects: _Py_interp_cached_objects, pub static_objects: _Py_interp_static_objects, pub _initial_thread: _PyThreadStateImpl, pub _interactive_src_count: Py_ssize_t, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _is_pythreads { pub next_unique_id: u64, pub head: *mut PyThreadState, pub main: *mut PyThreadState, pub count: Py_ssize_t, pub stacksize: usize, } impl Default for _is_pythreads { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for _is { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type sig_atomic_t = __sig_atomic_t; #[repr(C)] #[derive(Copy, Clone)] pub union sigval { pub sival_int: ::std::os::raw::c_int, pub sival_ptr: *mut ::std::os::raw::c_void, _bindgen_union_align: u64, } impl Default for sigval { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __sigval_t = sigval; #[repr(C)] #[derive(Copy, Clone)] pub struct siginfo_t { pub si_signo: ::std::os::raw::c_int, pub si_errno: ::std::os::raw::c_int, pub si_code: ::std::os::raw::c_int, pub __pad0: ::std::os::raw::c_int, pub _sifields: siginfo_t__bindgen_ty_1, } #[repr(C)] #[derive(Copy, Clone)] pub union siginfo_t__bindgen_ty_1 { pub _pad: [::std::os::raw::c_int; 28usize], pub _kill: siginfo_t__bindgen_ty_1__bindgen_ty_1, pub _timer: siginfo_t__bindgen_ty_1__bindgen_ty_2, pub _rt: siginfo_t__bindgen_ty_1__bindgen_ty_3, pub _sigchld: siginfo_t__bindgen_ty_1__bindgen_ty_4, pub _sigfault: siginfo_t__bindgen_ty_1__bindgen_ty_5, pub _sigpoll: siginfo_t__bindgen_ty_1__bindgen_ty_6, pub _sigsys: siginfo_t__bindgen_ty_1__bindgen_ty_7, _bindgen_union_align: [u64; 14usize], } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct siginfo_t__bindgen_ty_1__bindgen_ty_1 { pub si_pid: __pid_t, pub si_uid: __uid_t, } #[repr(C)] #[derive(Copy, Clone)] pub struct siginfo_t__bindgen_ty_1__bindgen_ty_2 { pub si_tid: ::std::os::raw::c_int, pub si_overrun: ::std::os::raw::c_int, pub si_sigval: __sigval_t, } impl Default for siginfo_t__bindgen_ty_1__bindgen_ty_2 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct siginfo_t__bindgen_ty_1__bindgen_ty_3 { pub si_pid: __pid_t, pub si_uid: __uid_t, pub si_sigval: __sigval_t, } impl Default for siginfo_t__bindgen_ty_1__bindgen_ty_3 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct siginfo_t__bindgen_ty_1__bindgen_ty_4 { pub si_pid: __pid_t, pub si_uid: __uid_t, pub si_status: ::std::os::raw::c_int, pub si_utime: __clock_t, pub si_stime: __clock_t, } #[repr(C)] #[derive(Copy, Clone)] pub struct siginfo_t__bindgen_ty_1__bindgen_ty_5 { pub si_addr: *mut ::std::os::raw::c_void, pub si_addr_lsb: ::std::os::raw::c_short, pub _bounds: siginfo_t__bindgen_ty_1__bindgen_ty_5__bindgen_ty_1, } #[repr(C)] #[derive(Copy, Clone)] pub union siginfo_t__bindgen_ty_1__bindgen_ty_5__bindgen_ty_1 { pub _addr_bnd: siginfo_t__bindgen_ty_1__bindgen_ty_5__bindgen_ty_1__bindgen_ty_1, pub _pkey: __uint32_t, _bindgen_union_align: [u64; 2usize], } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct siginfo_t__bindgen_ty_1__bindgen_ty_5__bindgen_ty_1__bindgen_ty_1 { pub _lower: *mut ::std::os::raw::c_void, pub _upper: *mut ::std::os::raw::c_void, } impl Default for siginfo_t__bindgen_ty_1__bindgen_ty_5__bindgen_ty_1__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for siginfo_t__bindgen_ty_1__bindgen_ty_5__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for siginfo_t__bindgen_ty_1__bindgen_ty_5 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct siginfo_t__bindgen_ty_1__bindgen_ty_6 { pub si_band: ::std::os::raw::c_long, pub si_fd: ::std::os::raw::c_int, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct siginfo_t__bindgen_ty_1__bindgen_ty_7 { pub _call_addr: *mut ::std::os::raw::c_void, pub _syscall: ::std::os::raw::c_int, pub _arch: ::std::os::raw::c_uint, } impl Default for siginfo_t__bindgen_ty_1__bindgen_ty_7 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for siginfo_t__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for siginfo_t { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __sighandler_t = ::std::option::Option; #[repr(C)] #[derive(Copy, Clone)] pub struct sigaction { pub __sigaction_handler: sigaction__bindgen_ty_1, pub sa_mask: __sigset_t, pub sa_flags: ::std::os::raw::c_int, pub sa_restorer: ::std::option::Option, } #[repr(C)] #[derive(Copy, Clone)] pub union sigaction__bindgen_ty_1 { pub sa_handler: __sighandler_t, pub sa_sigaction: ::std::option::Option< unsafe extern "C" fn( arg1: ::std::os::raw::c_int, arg2: *mut siginfo_t, arg3: *mut ::std::os::raw::c_void, ), >, _bindgen_union_align: u64, } impl Default for sigaction__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for sigaction { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct stack_t { pub ss_sp: *mut ::std::os::raw::c_void, pub ss_flags: ::std::os::raw::c_int, pub ss_size: usize, } impl Default for stack_t { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type _Py_sighandler_t = sigaction; #[repr(C)] #[derive(Copy, Clone)] pub struct faulthandler_user_signal { pub enabled: ::std::os::raw::c_int, pub file: *mut PyObject, pub fd: ::std::os::raw::c_int, pub all_threads: ::std::os::raw::c_int, pub chain: ::std::os::raw::c_int, pub previous: _Py_sighandler_t, pub interp: *mut PyInterpreterState, } impl Default for faulthandler_user_signal { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _faulthandler_runtime_state { pub fatal_error: _faulthandler_runtime_state__bindgen_ty_1, pub thread: _faulthandler_runtime_state__bindgen_ty_2, pub user_signals: *mut faulthandler_user_signal, pub stack: stack_t, pub old_stack: stack_t, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _faulthandler_runtime_state__bindgen_ty_1 { pub enabled: ::std::os::raw::c_int, pub file: *mut PyObject, pub fd: ::std::os::raw::c_int, pub all_threads: ::std::os::raw::c_int, pub interp: *mut PyInterpreterState, } impl Default for _faulthandler_runtime_state__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _faulthandler_runtime_state__bindgen_ty_2 { pub file: *mut PyObject, pub fd: ::std::os::raw::c_int, pub timeout_us: ::std::os::raw::c_longlong, pub repeat: ::std::os::raw::c_int, pub interp: *mut PyInterpreterState, pub exit: ::std::os::raw::c_int, pub header: *mut ::std::os::raw::c_char, pub header_len: usize, pub cancel_event: PyThread_type_lock, pub running: PyThread_type_lock, } impl Default for _faulthandler_runtime_state__bindgen_ty_2 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for _faulthandler_runtime_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type identifier = *mut PyObject; pub type string = *mut PyObject; pub type constant = *mut PyObject; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct asdl_int_seq { pub size: Py_ssize_t, pub elements: *mut *mut ::std::os::raw::c_void, pub typed_elements: [::std::os::raw::c_int; 1usize], } impl Default for asdl_int_seq { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type expr_ty = *mut _expr; pub const _expr_context_Load: _expr_context = 1; pub const _expr_context_Store: _expr_context = 2; pub const _expr_context_Del: _expr_context = 3; pub type _expr_context = u32; pub use self::_expr_context as expr_context_ty; pub const _boolop_And: _boolop = 1; pub const _boolop_Or: _boolop = 2; pub type _boolop = u32; pub use self::_boolop as boolop_ty; pub const _operator_Add: _operator = 1; pub const _operator_Sub: _operator = 2; pub const _operator_Mult: _operator = 3; pub const _operator_MatMult: _operator = 4; pub const _operator_Div: _operator = 5; pub const _operator_Mod: _operator = 6; pub const _operator_Pow: _operator = 7; pub const _operator_LShift: _operator = 8; pub const _operator_RShift: _operator = 9; pub const _operator_BitOr: _operator = 10; pub const _operator_BitXor: _operator = 11; pub const _operator_BitAnd: _operator = 12; pub const _operator_FloorDiv: _operator = 13; pub type _operator = u32; pub use self::_operator as operator_ty; pub const _unaryop_Invert: _unaryop = 1; pub const _unaryop_Not: _unaryop = 2; pub const _unaryop_UAdd: _unaryop = 3; pub const _unaryop_USub: _unaryop = 4; pub type _unaryop = u32; pub use self::_unaryop as unaryop_ty; pub type comprehension_ty = *mut _comprehension; pub type arguments_ty = *mut _arguments; pub type arg_ty = *mut _arg; pub type keyword_ty = *mut _keyword; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct asdl_expr_seq { pub size: Py_ssize_t, pub elements: *mut *mut ::std::os::raw::c_void, pub typed_elements: [expr_ty; 1usize], } impl Default for asdl_expr_seq { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct asdl_comprehension_seq { pub size: Py_ssize_t, pub elements: *mut *mut ::std::os::raw::c_void, pub typed_elements: [comprehension_ty; 1usize], } impl Default for asdl_comprehension_seq { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct asdl_arg_seq { pub size: Py_ssize_t, pub elements: *mut *mut ::std::os::raw::c_void, pub typed_elements: [arg_ty; 1usize], } impl Default for asdl_arg_seq { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct asdl_keyword_seq { pub size: Py_ssize_t, pub elements: *mut *mut ::std::os::raw::c_void, pub typed_elements: [keyword_ty; 1usize], } impl Default for asdl_keyword_seq { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub const _expr_kind_BoolOp_kind: _expr_kind = 1; pub const _expr_kind_NamedExpr_kind: _expr_kind = 2; pub const _expr_kind_BinOp_kind: _expr_kind = 3; pub const _expr_kind_UnaryOp_kind: _expr_kind = 4; pub const _expr_kind_Lambda_kind: _expr_kind = 5; pub const _expr_kind_IfExp_kind: _expr_kind = 6; pub const _expr_kind_Dict_kind: _expr_kind = 7; pub const _expr_kind_Set_kind: _expr_kind = 8; pub const _expr_kind_ListComp_kind: _expr_kind = 9; pub const _expr_kind_SetComp_kind: _expr_kind = 10; pub const _expr_kind_DictComp_kind: _expr_kind = 11; pub const _expr_kind_GeneratorExp_kind: _expr_kind = 12; pub const _expr_kind_Await_kind: _expr_kind = 13; pub const _expr_kind_Yield_kind: _expr_kind = 14; pub const _expr_kind_YieldFrom_kind: _expr_kind = 15; pub const _expr_kind_Compare_kind: _expr_kind = 16; pub const _expr_kind_Call_kind: _expr_kind = 17; pub const _expr_kind_FormattedValue_kind: _expr_kind = 18; pub const _expr_kind_JoinedStr_kind: _expr_kind = 19; pub const _expr_kind_Constant_kind: _expr_kind = 20; pub const _expr_kind_Attribute_kind: _expr_kind = 21; pub const _expr_kind_Subscript_kind: _expr_kind = 22; pub const _expr_kind_Starred_kind: _expr_kind = 23; pub const _expr_kind_Name_kind: _expr_kind = 24; pub const _expr_kind_List_kind: _expr_kind = 25; pub const _expr_kind_Tuple_kind: _expr_kind = 26; pub const _expr_kind_Slice_kind: _expr_kind = 27; pub type _expr_kind = u32; #[repr(C)] #[derive(Copy, Clone)] pub struct _expr { pub kind: _expr_kind, pub v: _expr__bindgen_ty_1, pub lineno: ::std::os::raw::c_int, pub col_offset: ::std::os::raw::c_int, pub end_lineno: ::std::os::raw::c_int, pub end_col_offset: ::std::os::raw::c_int, } #[repr(C)] #[derive(Copy, Clone)] pub union _expr__bindgen_ty_1 { pub BoolOp: _expr__bindgen_ty_1__bindgen_ty_1, pub NamedExpr: _expr__bindgen_ty_1__bindgen_ty_2, pub BinOp: _expr__bindgen_ty_1__bindgen_ty_3, pub UnaryOp: _expr__bindgen_ty_1__bindgen_ty_4, pub Lambda: _expr__bindgen_ty_1__bindgen_ty_5, pub IfExp: _expr__bindgen_ty_1__bindgen_ty_6, pub Dict: _expr__bindgen_ty_1__bindgen_ty_7, pub Set: _expr__bindgen_ty_1__bindgen_ty_8, pub ListComp: _expr__bindgen_ty_1__bindgen_ty_9, pub SetComp: _expr__bindgen_ty_1__bindgen_ty_10, pub DictComp: _expr__bindgen_ty_1__bindgen_ty_11, pub GeneratorExp: _expr__bindgen_ty_1__bindgen_ty_12, pub Await: _expr__bindgen_ty_1__bindgen_ty_13, pub Yield: _expr__bindgen_ty_1__bindgen_ty_14, pub YieldFrom: _expr__bindgen_ty_1__bindgen_ty_15, pub Compare: _expr__bindgen_ty_1__bindgen_ty_16, pub Call: _expr__bindgen_ty_1__bindgen_ty_17, pub FormattedValue: _expr__bindgen_ty_1__bindgen_ty_18, pub JoinedStr: _expr__bindgen_ty_1__bindgen_ty_19, pub Constant: _expr__bindgen_ty_1__bindgen_ty_20, pub Attribute: _expr__bindgen_ty_1__bindgen_ty_21, pub Subscript: _expr__bindgen_ty_1__bindgen_ty_22, pub Starred: _expr__bindgen_ty_1__bindgen_ty_23, pub Name: _expr__bindgen_ty_1__bindgen_ty_24, pub List: _expr__bindgen_ty_1__bindgen_ty_25, pub Tuple: _expr__bindgen_ty_1__bindgen_ty_26, pub Slice: _expr__bindgen_ty_1__bindgen_ty_27, _bindgen_union_align: [u64; 3usize], } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_1 { pub op: boolop_ty, pub values: *mut asdl_expr_seq, } impl Default for _expr__bindgen_ty_1__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_2 { pub target: expr_ty, pub value: expr_ty, } impl Default for _expr__bindgen_ty_1__bindgen_ty_2 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_3 { pub left: expr_ty, pub op: operator_ty, pub right: expr_ty, } impl Default for _expr__bindgen_ty_1__bindgen_ty_3 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_4 { pub op: unaryop_ty, pub operand: expr_ty, } impl Default for _expr__bindgen_ty_1__bindgen_ty_4 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_5 { pub args: arguments_ty, pub body: expr_ty, } impl Default for _expr__bindgen_ty_1__bindgen_ty_5 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_6 { pub test: expr_ty, pub body: expr_ty, pub orelse: expr_ty, } impl Default for _expr__bindgen_ty_1__bindgen_ty_6 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_7 { pub keys: *mut asdl_expr_seq, pub values: *mut asdl_expr_seq, } impl Default for _expr__bindgen_ty_1__bindgen_ty_7 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_8 { pub elts: *mut asdl_expr_seq, } impl Default for _expr__bindgen_ty_1__bindgen_ty_8 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_9 { pub elt: expr_ty, pub generators: *mut asdl_comprehension_seq, } impl Default for _expr__bindgen_ty_1__bindgen_ty_9 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_10 { pub elt: expr_ty, pub generators: *mut asdl_comprehension_seq, } impl Default for _expr__bindgen_ty_1__bindgen_ty_10 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_11 { pub key: expr_ty, pub value: expr_ty, pub generators: *mut asdl_comprehension_seq, } impl Default for _expr__bindgen_ty_1__bindgen_ty_11 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_12 { pub elt: expr_ty, pub generators: *mut asdl_comprehension_seq, } impl Default for _expr__bindgen_ty_1__bindgen_ty_12 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_13 { pub value: expr_ty, } impl Default for _expr__bindgen_ty_1__bindgen_ty_13 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_14 { pub value: expr_ty, } impl Default for _expr__bindgen_ty_1__bindgen_ty_14 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_15 { pub value: expr_ty, } impl Default for _expr__bindgen_ty_1__bindgen_ty_15 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_16 { pub left: expr_ty, pub ops: *mut asdl_int_seq, pub comparators: *mut asdl_expr_seq, } impl Default for _expr__bindgen_ty_1__bindgen_ty_16 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_17 { pub func: expr_ty, pub args: *mut asdl_expr_seq, pub keywords: *mut asdl_keyword_seq, } impl Default for _expr__bindgen_ty_1__bindgen_ty_17 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_18 { pub value: expr_ty, pub conversion: ::std::os::raw::c_int, pub format_spec: expr_ty, } impl Default for _expr__bindgen_ty_1__bindgen_ty_18 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_19 { pub values: *mut asdl_expr_seq, } impl Default for _expr__bindgen_ty_1__bindgen_ty_19 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_20 { pub value: constant, pub kind: string, } impl Default for _expr__bindgen_ty_1__bindgen_ty_20 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_21 { pub value: expr_ty, pub attr: identifier, pub ctx: expr_context_ty, } impl Default for _expr__bindgen_ty_1__bindgen_ty_21 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_22 { pub value: expr_ty, pub slice: expr_ty, pub ctx: expr_context_ty, } impl Default for _expr__bindgen_ty_1__bindgen_ty_22 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_23 { pub value: expr_ty, pub ctx: expr_context_ty, } impl Default for _expr__bindgen_ty_1__bindgen_ty_23 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_24 { pub id: identifier, pub ctx: expr_context_ty, } impl Default for _expr__bindgen_ty_1__bindgen_ty_24 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_25 { pub elts: *mut asdl_expr_seq, pub ctx: expr_context_ty, } impl Default for _expr__bindgen_ty_1__bindgen_ty_25 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_26 { pub elts: *mut asdl_expr_seq, pub ctx: expr_context_ty, } impl Default for _expr__bindgen_ty_1__bindgen_ty_26 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _expr__bindgen_ty_1__bindgen_ty_27 { pub lower: expr_ty, pub upper: expr_ty, pub step: expr_ty, } impl Default for _expr__bindgen_ty_1__bindgen_ty_27 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for _expr__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for _expr { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _comprehension { pub target: expr_ty, pub iter: expr_ty, pub ifs: *mut asdl_expr_seq, pub is_async: ::std::os::raw::c_int, } impl Default for _comprehension { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _arguments { pub posonlyargs: *mut asdl_arg_seq, pub args: *mut asdl_arg_seq, pub vararg: arg_ty, pub kwonlyargs: *mut asdl_arg_seq, pub kw_defaults: *mut asdl_expr_seq, pub kwarg: arg_ty, pub defaults: *mut asdl_expr_seq, } impl Default for _arguments { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _arg { pub arg: identifier, pub annotation: expr_ty, pub type_comment: string, pub lineno: ::std::os::raw::c_int, pub col_offset: ::std::os::raw::c_int, pub end_lineno: ::std::os::raw::c_int, pub end_col_offset: ::std::os::raw::c_int, } impl Default for _arg { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _keyword { pub arg: identifier, pub value: expr_ty, pub lineno: ::std::os::raw::c_int, pub col_offset: ::std::os::raw::c_int, pub end_lineno: ::std::os::raw::c_int, pub end_col_offset: ::std::os::raw::c_int, } impl Default for _keyword { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _parser_runtime_state { pub _not_used: ::std::os::raw::c_int, pub dummy_name: _expr, } impl Default for _parser_runtime_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct pyhash_runtime_state { pub urandom_cache: pyhash_runtime_state__bindgen_ty_1, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct pyhash_runtime_state__bindgen_ty_1 { pub fd: ::std::os::raw::c_int, pub st_dev: dev_t, pub st_ino: ino_t, } #[repr(C)] #[derive(Copy, Clone)] pub struct _signals_runtime_state { pub handlers: [_signals_runtime_state__bindgen_ty_1; 65usize], pub wakeup: _signals_runtime_state__bindgen_ty_2, pub is_tripped: ::std::os::raw::c_int, pub default_handler: *mut PyObject, pub ignore_handler: *mut PyObject, pub unhandled_keyboard_interrupt: ::std::os::raw::c_int, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _signals_runtime_state__bindgen_ty_1 { pub tripped: ::std::os::raw::c_int, pub func: *mut PyObject, } impl Default for _signals_runtime_state__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _signals_runtime_state__bindgen_ty_2 { pub fd: sig_atomic_t, pub warn_on_full_buffer: ::std::os::raw::c_int, } impl Default for _signals_runtime_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _PyTraceMalloc_Config { pub initialized: _PyTraceMalloc_Config__bindgen_ty_1, pub tracing: ::std::os::raw::c_int, pub max_nframe: ::std::os::raw::c_int, } pub const _PyTraceMalloc_Config_TRACEMALLOC_NOT_INITIALIZED: _PyTraceMalloc_Config__bindgen_ty_1 = 0; pub const _PyTraceMalloc_Config_TRACEMALLOC_INITIALIZED: _PyTraceMalloc_Config__bindgen_ty_1 = 1; pub const _PyTraceMalloc_Config_TRACEMALLOC_FINALIZED: _PyTraceMalloc_Config__bindgen_ty_1 = 2; pub type _PyTraceMalloc_Config__bindgen_ty_1 = u32; impl Default for _PyTraceMalloc_Config { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C, packed)] #[derive(Debug, Copy, Clone)] pub struct tracemalloc_frame { pub filename: *mut PyObject, pub lineno: ::std::os::raw::c_uint, } impl Default for tracemalloc_frame { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct tracemalloc_traceback { pub hash: Py_uhash_t, pub nframe: u16, pub total_nframe: u16, pub frames: [tracemalloc_frame; 1usize], } impl Default for tracemalloc_traceback { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _tracemalloc_runtime_state { pub config: _PyTraceMalloc_Config, pub allocators: _tracemalloc_runtime_state__bindgen_ty_1, pub tables_lock: PyThread_type_lock, pub traced_memory: usize, pub peak_traced_memory: usize, pub filenames: *mut _Py_hashtable_t, pub traceback: *mut tracemalloc_traceback, pub tracebacks: *mut _Py_hashtable_t, pub traces: *mut _Py_hashtable_t, pub domains: *mut _Py_hashtable_t, pub empty_traceback: tracemalloc_traceback, pub reentrant_key: Py_tss_t, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _tracemalloc_runtime_state__bindgen_ty_1 { pub mem: PyMemAllocatorEx, pub raw: PyMemAllocatorEx, pub obj: PyMemAllocatorEx, } impl Default for _tracemalloc_runtime_state__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for _tracemalloc_runtime_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _getargs_runtime_state { pub static_parsers: *mut _PyArg_Parser, } impl Default for _getargs_runtime_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _gilstate_runtime_state { pub check_enabled: ::std::os::raw::c_int, pub autoInterpreterState: *mut PyInterpreterState, } impl Default for _gilstate_runtime_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_AuditHookEntry { pub next: *mut _Py_AuditHookEntry, pub hookCFunction: Py_AuditHookFunction, pub userData: *mut ::std::os::raw::c_void, } impl Default for _Py_AuditHookEntry { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_DebugOffsets { pub cookie: [::std::os::raw::c_char; 8usize], pub version: u64, pub free_threaded: u64, pub runtime_state: _Py_DebugOffsets__runtime_state, pub interpreter_state: _Py_DebugOffsets__interpreter_state, pub thread_state: _Py_DebugOffsets__thread_state, pub interpreter_frame: _Py_DebugOffsets__interpreter_frame, pub code_object: _Py_DebugOffsets__code_object, pub pyobject: _Py_DebugOffsets__pyobject, pub type_object: _Py_DebugOffsets__type_object, pub tuple_object: _Py_DebugOffsets__tuple_object, pub list_object: _Py_DebugOffsets__list_object, pub dict_object: _Py_DebugOffsets__dict_object, pub float_object: _Py_DebugOffsets__float_object, pub long_object: _Py_DebugOffsets__long_object, pub bytes_object: _Py_DebugOffsets__bytes_object, pub unicode_object: _Py_DebugOffsets__unicode_object, pub gc: _Py_DebugOffsets__gc, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_DebugOffsets__runtime_state { pub size: u64, pub finalizing: u64, pub interpreters_head: u64, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_DebugOffsets__interpreter_state { pub size: u64, pub id: u64, pub next: u64, pub threads_head: u64, pub gc: u64, pub imports_modules: u64, pub sysdict: u64, pub builtins: u64, pub ceval_gil: u64, pub gil_runtime_state: u64, pub gil_runtime_state_enabled: u64, pub gil_runtime_state_locked: u64, pub gil_runtime_state_holder: u64, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_DebugOffsets__thread_state { pub size: u64, pub prev: u64, pub next: u64, pub interp: u64, pub current_frame: u64, pub thread_id: u64, pub native_thread_id: u64, pub datastack_chunk: u64, pub status: u64, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_DebugOffsets__interpreter_frame { pub size: u64, pub previous: u64, pub executable: u64, pub instr_ptr: u64, pub localsplus: u64, pub owner: u64, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_DebugOffsets__code_object { pub size: u64, pub filename: u64, pub name: u64, pub qualname: u64, pub linetable: u64, pub firstlineno: u64, pub argcount: u64, pub localsplusnames: u64, pub localspluskinds: u64, pub co_code_adaptive: u64, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_DebugOffsets__pyobject { pub size: u64, pub ob_type: u64, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_DebugOffsets__type_object { pub size: u64, pub tp_name: u64, pub tp_repr: u64, pub tp_flags: u64, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_DebugOffsets__tuple_object { pub size: u64, pub ob_item: u64, pub ob_size: u64, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_DebugOffsets__list_object { pub size: u64, pub ob_item: u64, pub ob_size: u64, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_DebugOffsets__dict_object { pub size: u64, pub ma_keys: u64, pub ma_values: u64, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_DebugOffsets__float_object { pub size: u64, pub ob_fval: u64, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_DebugOffsets__long_object { pub size: u64, pub lv_tag: u64, pub ob_digit: u64, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_DebugOffsets__bytes_object { pub size: u64, pub ob_size: u64, pub ob_sval: u64, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_DebugOffsets__unicode_object { pub size: u64, pub state: u64, pub length: u64, pub asciiobject_size: u64, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_DebugOffsets__gc { pub size: u64, pub collecting: u64, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _reftracer_runtime_state { pub tracer_func: PyRefTracer, pub tracer_data: *mut ::std::os::raw::c_void, } impl Default for _reftracer_runtime_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct pyruntimestate { pub debug_offsets: _Py_DebugOffsets, pub _initialized: ::std::os::raw::c_int, pub preinitializing: ::std::os::raw::c_int, pub preinitialized: ::std::os::raw::c_int, pub core_initialized: ::std::os::raw::c_int, pub initialized: ::std::os::raw::c_int, pub _finalizing: *mut PyThreadState, pub _finalizing_id: ::std::os::raw::c_ulong, pub interpreters: pyruntimestate_pyinterpreters, pub main_thread: ::std::os::raw::c_ulong, pub main_tstate: *mut PyThreadState, pub xi: _xi_runtime_state, pub allocators: _pymem_allocators, pub obmalloc: _obmalloc_global_state, pub pyhash_state: pyhash_runtime_state, pub threads: _pythread_runtime_state, pub signals: _signals_runtime_state, pub autoTSSkey: Py_tss_t, pub trashTSSkey: Py_tss_t, pub orig_argv: PyWideStringList, pub parser: _parser_runtime_state, pub atexit: _atexit_runtime_state, pub imports: _import_runtime_state, pub ceval: _ceval_runtime_state, pub gilstate: _gilstate_runtime_state, pub getargs: _getargs_runtime_state, pub fileutils: _fileutils_state, pub faulthandler: _faulthandler_runtime_state, pub tracemalloc: _tracemalloc_runtime_state, pub ref_tracer: _reftracer_runtime_state, pub stoptheworld_mutex: _PyRWMutex, pub stoptheworld: _stoptheworld_state, pub preconfig: PyPreConfig, pub open_code_hook: Py_OpenCodeHookFunction, pub open_code_userdata: *mut ::std::os::raw::c_void, pub audit_hooks: pyruntimestate__bindgen_ty_1, pub object_state: _py_object_runtime_state, pub float_state: _Py_float_runtime_state, pub unicode_state: _Py_unicode_runtime_state, pub types: _types_runtime_state, pub cached_objects: _Py_cached_objects, pub static_objects: _Py_static_objects, pub _main_interpreter: PyInterpreterState, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct pyruntimestate_pyinterpreters { pub mutex: PyMutex, pub head: *mut PyInterpreterState, pub main: *mut PyInterpreterState, pub next_id: i64, } impl Default for pyruntimestate_pyinterpreters { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct pyruntimestate__bindgen_ty_1 { pub mutex: PyMutex, pub head: *mut _Py_AuditHookEntry, } impl Default for pyruntimestate__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for pyruntimestate { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Default)] pub struct _dictkeysobject { pub dk_refcnt: Py_ssize_t, pub dk_log2_size: u8, pub dk_log2_index_bytes: u8, pub dk_kind: u8, pub dk_version: u32, pub dk_usable: Py_ssize_t, pub dk_nentries: Py_ssize_t, pub dk_indices: __IncompleteArrayField<::std::os::raw::c_char>, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _dictvalues { pub capacity: u8, pub size: u8, pub embedded: u8, pub valid: u8, pub values: [*mut PyObject; 1usize], } impl Default for _dictvalues { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _PyAsyncGenWrappedValue { pub _address: u8, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct PyAsyncGenASend { pub _address: u8, } ================================================ FILE: src/python_bindings/v3_3_7.rs ================================================ // Generated bindings for python v3.3.7 #![allow(dead_code)] #![allow(non_upper_case_globals)] #![allow(non_camel_case_types)] #![allow(non_snake_case)] #![allow(clippy::useless_transmute)] #![allow(clippy::default_trait_access)] #![allow(clippy::cast_lossless)] #![allow(clippy::trivially_copy_pass_by_ref)] #![allow(clippy::upper_case_acronyms)] /* automatically generated by rust-bindgen */ #[repr(C)] #[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] pub struct __BindgenBitfieldUnit where Storage: AsRef<[u8]> + AsMut<[u8]>, { storage: Storage, align: [Align; 0], } impl __BindgenBitfieldUnit where Storage: AsRef<[u8]> + AsMut<[u8]>, { #[inline] pub fn new(storage: Storage) -> Self { Self { storage, align: [] } } #[inline] pub fn get_bit(&self, index: usize) -> bool { debug_assert!(index / 8 < self.storage.as_ref().len()); let byte_index = index / 8; let byte = self.storage.as_ref()[byte_index]; let bit_index = index % 8; let mask = 1 << bit_index; byte & mask == mask } #[inline] pub fn set_bit(&mut self, index: usize, val: bool) { debug_assert!(index / 8 < self.storage.as_ref().len()); let byte_index = index / 8; let byte = &mut self.storage.as_mut()[byte_index]; let bit_index = index % 8; let mask = 1 << bit_index; if val { *byte |= mask; } else { *byte &= !mask; } } #[inline] pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); let mut val = 0; for i in 0..(bit_width as usize) { if self.get_bit(i + bit_offset) { val |= 1 << i; } } val } #[inline] pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); for i in 0..(bit_width as usize) { let mask = 1 << i; let val_bit_is_set = val & mask == mask; self.set_bit(i + bit_offset, val_bit_is_set); } } } pub type __int64_t = ::std::os::raw::c_longlong; pub type __darwin_wchar_t = ::std::os::raw::c_int; pub type __darwin_ssize_t = ::std::os::raw::c_long; pub type __darwin_off_t = __int64_t; pub type fpos_t = __darwin_off_t; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct __sbuf { pub _base: *mut ::std::os::raw::c_uchar, pub _size: ::std::os::raw::c_int, } impl Default for __sbuf { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct __sFILEX { _unused: [u8; 0], } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct __sFILE { pub _p: *mut ::std::os::raw::c_uchar, pub _r: ::std::os::raw::c_int, pub _w: ::std::os::raw::c_int, pub _flags: ::std::os::raw::c_short, pub _file: ::std::os::raw::c_short, pub _bf: __sbuf, pub _lbfsize: ::std::os::raw::c_int, pub _cookie: *mut ::std::os::raw::c_void, pub _close: ::std::option::Option< unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, >, pub _read: ::std::option::Option< unsafe extern "C" fn( arg1: *mut ::std::os::raw::c_void, arg2: *mut ::std::os::raw::c_char, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >, pub _seek: ::std::option::Option< unsafe extern "C" fn( arg1: *mut ::std::os::raw::c_void, arg2: fpos_t, arg3: ::std::os::raw::c_int, ) -> fpos_t, >, pub _write: ::std::option::Option< unsafe extern "C" fn( arg1: *mut ::std::os::raw::c_void, arg2: *const ::std::os::raw::c_char, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >, pub _ub: __sbuf, pub _extra: *mut __sFILEX, pub _ur: ::std::os::raw::c_int, pub _ubuf: [::std::os::raw::c_uchar; 3usize], pub _nbuf: [::std::os::raw::c_uchar; 1usize], pub _lb: __sbuf, pub _blksize: ::std::os::raw::c_int, pub _offset: fpos_t, } impl Default for __sFILE { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type FILE = __sFILE; pub type wchar_t = __darwin_wchar_t; pub type Py_ssize_t = isize; pub type Py_hash_t = Py_ssize_t; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _object { pub ob_refcnt: Py_ssize_t, pub ob_type: *mut _typeobject, } impl Default for _object { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyObject = _object; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyVarObject { pub ob_base: PyObject, pub ob_size: Py_ssize_t, } impl Default for PyVarObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type unaryfunc = ::std::option::Option *mut PyObject>; pub type binaryfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject, >; pub type ternaryfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> *mut PyObject, >; pub type inquiry = ::std::option::Option ::std::os::raw::c_int>; pub type lenfunc = ::std::option::Option Py_ssize_t>; pub type ssizeargfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: Py_ssize_t) -> *mut PyObject, >; pub type ssizeobjargproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: Py_ssize_t, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type objobjargproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct bufferinfo { pub buf: *mut ::std::os::raw::c_void, pub obj: *mut PyObject, pub len: Py_ssize_t, pub itemsize: Py_ssize_t, pub readonly: ::std::os::raw::c_int, pub ndim: ::std::os::raw::c_int, pub format: *mut ::std::os::raw::c_char, pub shape: *mut Py_ssize_t, pub strides: *mut Py_ssize_t, pub suboffsets: *mut Py_ssize_t, pub internal: *mut ::std::os::raw::c_void, } impl Default for bufferinfo { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type Py_buffer = bufferinfo; pub type getbufferproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut Py_buffer, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >; pub type releasebufferproc = ::std::option::Option; pub type objobjproc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> ::std::os::raw::c_int, >; pub type visitproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; pub type traverseproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: visitproc, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyNumberMethods { pub nb_add: binaryfunc, pub nb_subtract: binaryfunc, pub nb_multiply: binaryfunc, pub nb_remainder: binaryfunc, pub nb_divmod: binaryfunc, pub nb_power: ternaryfunc, pub nb_negative: unaryfunc, pub nb_positive: unaryfunc, pub nb_absolute: unaryfunc, pub nb_bool: inquiry, pub nb_invert: unaryfunc, pub nb_lshift: binaryfunc, pub nb_rshift: binaryfunc, pub nb_and: binaryfunc, pub nb_xor: binaryfunc, pub nb_or: binaryfunc, pub nb_int: unaryfunc, pub nb_reserved: *mut ::std::os::raw::c_void, pub nb_float: unaryfunc, pub nb_inplace_add: binaryfunc, pub nb_inplace_subtract: binaryfunc, pub nb_inplace_multiply: binaryfunc, pub nb_inplace_remainder: binaryfunc, pub nb_inplace_power: ternaryfunc, pub nb_inplace_lshift: binaryfunc, pub nb_inplace_rshift: binaryfunc, pub nb_inplace_and: binaryfunc, pub nb_inplace_xor: binaryfunc, pub nb_inplace_or: binaryfunc, pub nb_floor_divide: binaryfunc, pub nb_true_divide: binaryfunc, pub nb_inplace_floor_divide: binaryfunc, pub nb_inplace_true_divide: binaryfunc, pub nb_index: unaryfunc, } impl Default for PyNumberMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PySequenceMethods { pub sq_length: lenfunc, pub sq_concat: binaryfunc, pub sq_repeat: ssizeargfunc, pub sq_item: ssizeargfunc, pub was_sq_slice: *mut ::std::os::raw::c_void, pub sq_ass_item: ssizeobjargproc, pub was_sq_ass_slice: *mut ::std::os::raw::c_void, pub sq_contains: objobjproc, pub sq_inplace_concat: binaryfunc, pub sq_inplace_repeat: ssizeargfunc, } impl Default for PySequenceMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyMappingMethods { pub mp_length: lenfunc, pub mp_subscript: binaryfunc, pub mp_ass_subscript: objobjargproc, } impl Default for PyMappingMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyBufferProcs { pub bf_getbuffer: getbufferproc, pub bf_releasebuffer: releasebufferproc, } impl Default for PyBufferProcs { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type freefunc = ::std::option::Option; pub type destructor = ::std::option::Option; pub type printfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut FILE, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >; pub type getattrfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_char) -> *mut PyObject, >; pub type getattrofunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject, >; pub type setattrfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_char, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type setattrofunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type reprfunc = ::std::option::Option *mut PyObject>; pub type hashfunc = ::std::option::Option Py_hash_t>; pub type richcmpfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: ::std::os::raw::c_int, ) -> *mut PyObject, >; pub type getiterfunc = ::std::option::Option *mut PyObject>; pub type iternextfunc = ::std::option::Option *mut PyObject>; pub type descrgetfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> *mut PyObject, >; pub type descrsetfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type initproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type newfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut _typeobject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> *mut PyObject, >; pub type allocfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut _typeobject, arg2: Py_ssize_t) -> *mut PyObject, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _typeobject { pub ob_base: PyVarObject, pub tp_name: *const ::std::os::raw::c_char, pub tp_basicsize: Py_ssize_t, pub tp_itemsize: Py_ssize_t, pub tp_dealloc: destructor, pub tp_print: printfunc, pub tp_getattr: getattrfunc, pub tp_setattr: setattrfunc, pub tp_reserved: *mut ::std::os::raw::c_void, pub tp_repr: reprfunc, pub tp_as_number: *mut PyNumberMethods, pub tp_as_sequence: *mut PySequenceMethods, pub tp_as_mapping: *mut PyMappingMethods, pub tp_hash: hashfunc, pub tp_call: ternaryfunc, pub tp_str: reprfunc, pub tp_getattro: getattrofunc, pub tp_setattro: setattrofunc, pub tp_as_buffer: *mut PyBufferProcs, pub tp_flags: ::std::os::raw::c_long, pub tp_doc: *const ::std::os::raw::c_char, pub tp_traverse: traverseproc, pub tp_clear: inquiry, pub tp_richcompare: richcmpfunc, pub tp_weaklistoffset: Py_ssize_t, pub tp_iter: getiterfunc, pub tp_iternext: iternextfunc, pub tp_methods: *mut PyMethodDef, pub tp_members: *mut PyMemberDef, pub tp_getset: *mut PyGetSetDef, pub tp_base: *mut _typeobject, pub tp_dict: *mut PyObject, pub tp_descr_get: descrgetfunc, pub tp_descr_set: descrsetfunc, pub tp_dictoffset: Py_ssize_t, pub tp_init: initproc, pub tp_alloc: allocfunc, pub tp_new: newfunc, pub tp_free: freefunc, pub tp_is_gc: inquiry, pub tp_bases: *mut PyObject, pub tp_mro: *mut PyObject, pub tp_cache: *mut PyObject, pub tp_subclasses: *mut PyObject, pub tp_weaklist: *mut PyObject, pub tp_del: destructor, pub tp_version_tag: ::std::os::raw::c_uint, } impl Default for _typeobject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyTypeObject = _typeobject; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyBytesObject { pub ob_base: PyVarObject, pub ob_shash: Py_hash_t, pub ob_sval: [::std::os::raw::c_char; 1usize], } impl Default for PyBytesObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type Py_UCS4 = ::std::os::raw::c_uint; pub type Py_UCS2 = ::std::os::raw::c_ushort; pub type Py_UCS1 = ::std::os::raw::c_uchar; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyASCIIObject { pub ob_base: PyObject, pub length: Py_ssize_t, pub hash: Py_hash_t, pub state: PyASCIIObject__bindgen_ty_1, pub wstr: *mut wchar_t, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct PyASCIIObject__bindgen_ty_1 { pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>, pub __bindgen_padding_0: [u8; 3usize], pub __bindgen_align: [u32; 0usize], } impl PyASCIIObject__bindgen_ty_1 { #[inline] pub fn interned(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) } } #[inline] pub fn set_interned(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(0usize, 2u8, val as u64) } } #[inline] pub fn kind(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 3u8) as u32) } } #[inline] pub fn set_kind(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(2usize, 3u8, val as u64) } } #[inline] pub fn compact(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } } #[inline] pub fn set_compact(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(5usize, 1u8, val as u64) } } #[inline] pub fn ascii(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } } #[inline] pub fn set_ascii(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(6usize, 1u8, val as u64) } } #[inline] pub fn ready(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } } #[inline] pub fn set_ready(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(7usize, 1u8, val as u64) } } #[inline] pub fn new_bitfield_1( interned: ::std::os::raw::c_uint, kind: ::std::os::raw::c_uint, compact: ::std::os::raw::c_uint, ascii: ::std::os::raw::c_uint, ready: ::std::os::raw::c_uint, ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> { let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> = Default::default(); __bindgen_bitfield_unit.set(0usize, 2u8, { let interned: u32 = unsafe { ::std::mem::transmute(interned) }; interned as u64 }); __bindgen_bitfield_unit.set(2usize, 3u8, { let kind: u32 = unsafe { ::std::mem::transmute(kind) }; kind as u64 }); __bindgen_bitfield_unit.set(5usize, 1u8, { let compact: u32 = unsafe { ::std::mem::transmute(compact) }; compact as u64 }); __bindgen_bitfield_unit.set(6usize, 1u8, { let ascii: u32 = unsafe { ::std::mem::transmute(ascii) }; ascii as u64 }); __bindgen_bitfield_unit.set(7usize, 1u8, { let ready: u32 = unsafe { ::std::mem::transmute(ready) }; ready as u64 }); __bindgen_bitfield_unit } } impl Default for PyASCIIObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyCompactUnicodeObject { pub _base: PyASCIIObject, pub utf8_length: Py_ssize_t, pub utf8: *mut ::std::os::raw::c_char, pub wstr_length: Py_ssize_t, } impl Default for PyCompactUnicodeObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct PyUnicodeObject { pub _base: PyCompactUnicodeObject, pub data: PyUnicodeObject__bindgen_ty_1, } #[repr(C)] #[derive(Copy, Clone)] pub union PyUnicodeObject__bindgen_ty_1 { pub any: *mut ::std::os::raw::c_void, pub latin1: *mut Py_UCS1, pub ucs2: *mut Py_UCS2, pub ucs4: *mut Py_UCS4, _bindgen_union_align: u64, } impl Default for PyUnicodeObject__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for PyUnicodeObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyLongObject = _longobject; pub type digit = u32; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _longobject { pub ob_base: PyVarObject, pub ob_digit: [digit; 1usize], } impl Default for _longobject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyFloatObject { pub ob_base: PyObject, pub ob_fval: f64, } impl Default for PyFloatObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyTupleObject { pub ob_base: PyVarObject, pub ob_item: [*mut PyObject; 1usize], } impl Default for PyTupleObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyListObject { pub ob_base: PyVarObject, pub ob_item: *mut *mut PyObject, pub allocated: Py_ssize_t, } impl Default for PyListObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyDictKeysObject = _dictkeysobject; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyDictObject { pub ob_base: PyObject, pub ma_used: Py_ssize_t, pub ma_keys: *mut PyDictKeysObject, pub ma_values: *mut *mut PyObject, } impl Default for PyDictObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyDictKeyEntry { pub me_hash: Py_hash_t, pub me_key: *mut PyObject, pub me_value: *mut PyObject, } impl Default for PyDictKeyEntry { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyCFunction = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyMethodDef { pub ml_name: *const ::std::os::raw::c_char, pub ml_meth: PyCFunction, pub ml_flags: ::std::os::raw::c_int, pub ml_doc: *const ::std::os::raw::c_char, } impl Default for PyMethodDef { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _is { pub next: *mut _is, pub tstate_head: *mut _ts, pub modules: *mut PyObject, pub modules_by_index: *mut PyObject, pub sysdict: *mut PyObject, pub builtins: *mut PyObject, pub importlib: *mut PyObject, pub codec_search_path: *mut PyObject, pub codec_search_cache: *mut PyObject, pub codec_error_registry: *mut PyObject, pub codecs_initialized: ::std::os::raw::c_int, pub fscodec_initialized: ::std::os::raw::c_int, pub dlopenflags: ::std::os::raw::c_int, } impl Default for _is { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyInterpreterState = _is; pub type Py_tracefunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut _frame, arg3: ::std::os::raw::c_int, arg4: *mut PyObject, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _ts { pub next: *mut _ts, pub interp: *mut PyInterpreterState, pub frame: *mut _frame, pub recursion_depth: ::std::os::raw::c_int, pub overflowed: ::std::os::raw::c_char, pub recursion_critical: ::std::os::raw::c_char, pub tracing: ::std::os::raw::c_int, pub use_tracing: ::std::os::raw::c_int, pub c_profilefunc: Py_tracefunc, pub c_tracefunc: Py_tracefunc, pub c_profileobj: *mut PyObject, pub c_traceobj: *mut PyObject, pub curexc_type: *mut PyObject, pub curexc_value: *mut PyObject, pub curexc_traceback: *mut PyObject, pub exc_type: *mut PyObject, pub exc_value: *mut PyObject, pub exc_traceback: *mut PyObject, pub dict: *mut PyObject, pub tick_counter: ::std::os::raw::c_int, pub gilstate_counter: ::std::os::raw::c_int, pub async_exc: *mut PyObject, pub thread_id: ::std::os::raw::c_long, pub trash_delete_nesting: ::std::os::raw::c_int, pub trash_delete_later: *mut PyObject, } impl Default for _ts { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyThreadState = _ts; pub type getter = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_void) -> *mut PyObject, >; pub type setter = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyGetSetDef { pub name: *mut ::std::os::raw::c_char, pub get: getter, pub set: setter, pub doc: *mut ::std::os::raw::c_char, pub closure: *mut ::std::os::raw::c_void, } impl Default for PyGetSetDef { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyMemberDef { _unused: [u8; 0], } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyCodeObject { pub ob_base: PyObject, pub co_argcount: ::std::os::raw::c_int, pub co_kwonlyargcount: ::std::os::raw::c_int, pub co_nlocals: ::std::os::raw::c_int, pub co_stacksize: ::std::os::raw::c_int, pub co_flags: ::std::os::raw::c_int, pub co_code: *mut PyObject, pub co_consts: *mut PyObject, pub co_names: *mut PyObject, pub co_varnames: *mut PyObject, pub co_freevars: *mut PyObject, pub co_cellvars: *mut PyObject, pub co_cell2arg: *mut ::std::os::raw::c_uchar, pub co_filename: *mut PyObject, pub co_name: *mut PyObject, pub co_firstlineno: ::std::os::raw::c_int, pub co_lnotab: *mut PyObject, pub co_zombieframe: *mut ::std::os::raw::c_void, pub co_weakreflist: *mut PyObject, } impl Default for PyCodeObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct PyTryBlock { pub b_type: ::std::os::raw::c_int, pub b_handler: ::std::os::raw::c_int, pub b_level: ::std::os::raw::c_int, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _frame { pub ob_base: PyVarObject, pub f_back: *mut _frame, pub f_code: *mut PyCodeObject, pub f_builtins: *mut PyObject, pub f_globals: *mut PyObject, pub f_locals: *mut PyObject, pub f_valuestack: *mut *mut PyObject, pub f_stacktop: *mut *mut PyObject, pub f_trace: *mut PyObject, pub f_exc_type: *mut PyObject, pub f_exc_value: *mut PyObject, pub f_exc_traceback: *mut PyObject, pub f_tstate: *mut PyThreadState, pub f_lasti: ::std::os::raw::c_int, pub f_lineno: ::std::os::raw::c_int, pub f_iblock: ::std::os::raw::c_int, pub f_blockstack: [PyTryBlock; 20usize], pub f_localsplus: [*mut PyObject; 1usize], } impl Default for _frame { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyFrameObject = _frame; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _dictkeysobject { pub _address: u8, } ================================================ FILE: src/python_bindings/v3_4_8.rs ================================================ // Generated bindings for python v3.4.8 #![allow(dead_code)] #![allow(non_upper_case_globals)] #![allow(non_camel_case_types)] #![allow(non_snake_case)] #![allow(clippy::useless_transmute)] #![allow(clippy::default_trait_access)] #![allow(clippy::cast_lossless)] #![allow(clippy::trivially_copy_pass_by_ref)] #![allow(clippy::upper_case_acronyms)] /* automatically generated by rust-bindgen */ #[repr(C)] #[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] pub struct __BindgenBitfieldUnit where Storage: AsRef<[u8]> + AsMut<[u8]>, { storage: Storage, align: [Align; 0], } impl __BindgenBitfieldUnit where Storage: AsRef<[u8]> + AsMut<[u8]>, { #[inline] pub fn new(storage: Storage) -> Self { Self { storage, align: [] } } #[inline] pub fn get_bit(&self, index: usize) -> bool { debug_assert!(index / 8 < self.storage.as_ref().len()); let byte_index = index / 8; let byte = self.storage.as_ref()[byte_index]; let bit_index = index % 8; let mask = 1 << bit_index; byte & mask == mask } #[inline] pub fn set_bit(&mut self, index: usize, val: bool) { debug_assert!(index / 8 < self.storage.as_ref().len()); let byte_index = index / 8; let byte = &mut self.storage.as_mut()[byte_index]; let bit_index = index % 8; let mask = 1 << bit_index; if val { *byte |= mask; } else { *byte &= !mask; } } #[inline] pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); let mut val = 0; for i in 0..(bit_width as usize) { if self.get_bit(i + bit_offset) { val |= 1 << i; } } val } #[inline] pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); for i in 0..(bit_width as usize) { let mask = 1 << i; let val_bit_is_set = val & mask == mask; self.set_bit(i + bit_offset, val_bit_is_set); } } } pub type __int64_t = ::std::os::raw::c_longlong; pub type __darwin_wchar_t = ::std::os::raw::c_int; pub type __darwin_ssize_t = ::std::os::raw::c_long; pub type __darwin_off_t = __int64_t; pub type fpos_t = __darwin_off_t; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct __sbuf { pub _base: *mut ::std::os::raw::c_uchar, pub _size: ::std::os::raw::c_int, } impl Default for __sbuf { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct __sFILEX { _unused: [u8; 0], } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct __sFILE { pub _p: *mut ::std::os::raw::c_uchar, pub _r: ::std::os::raw::c_int, pub _w: ::std::os::raw::c_int, pub _flags: ::std::os::raw::c_short, pub _file: ::std::os::raw::c_short, pub _bf: __sbuf, pub _lbfsize: ::std::os::raw::c_int, pub _cookie: *mut ::std::os::raw::c_void, pub _close: ::std::option::Option< unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, >, pub _read: ::std::option::Option< unsafe extern "C" fn( arg1: *mut ::std::os::raw::c_void, arg2: *mut ::std::os::raw::c_char, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >, pub _seek: ::std::option::Option< unsafe extern "C" fn( arg1: *mut ::std::os::raw::c_void, arg2: fpos_t, arg3: ::std::os::raw::c_int, ) -> fpos_t, >, pub _write: ::std::option::Option< unsafe extern "C" fn( arg1: *mut ::std::os::raw::c_void, arg2: *const ::std::os::raw::c_char, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >, pub _ub: __sbuf, pub _extra: *mut __sFILEX, pub _ur: ::std::os::raw::c_int, pub _ubuf: [::std::os::raw::c_uchar; 3usize], pub _nbuf: [::std::os::raw::c_uchar; 1usize], pub _lb: __sbuf, pub _blksize: ::std::os::raw::c_int, pub _offset: fpos_t, } impl Default for __sFILE { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type FILE = __sFILE; pub type wchar_t = __darwin_wchar_t; pub type Py_ssize_t = isize; pub type Py_hash_t = Py_ssize_t; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _object { pub ob_refcnt: Py_ssize_t, pub ob_type: *mut _typeobject, } impl Default for _object { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyObject = _object; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyVarObject { pub ob_base: PyObject, pub ob_size: Py_ssize_t, } impl Default for PyVarObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type unaryfunc = ::std::option::Option *mut PyObject>; pub type binaryfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject, >; pub type ternaryfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> *mut PyObject, >; pub type inquiry = ::std::option::Option ::std::os::raw::c_int>; pub type lenfunc = ::std::option::Option Py_ssize_t>; pub type ssizeargfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: Py_ssize_t) -> *mut PyObject, >; pub type ssizeobjargproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: Py_ssize_t, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type objobjargproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct bufferinfo { pub buf: *mut ::std::os::raw::c_void, pub obj: *mut PyObject, pub len: Py_ssize_t, pub itemsize: Py_ssize_t, pub readonly: ::std::os::raw::c_int, pub ndim: ::std::os::raw::c_int, pub format: *mut ::std::os::raw::c_char, pub shape: *mut Py_ssize_t, pub strides: *mut Py_ssize_t, pub suboffsets: *mut Py_ssize_t, pub internal: *mut ::std::os::raw::c_void, } impl Default for bufferinfo { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type Py_buffer = bufferinfo; pub type getbufferproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut Py_buffer, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >; pub type releasebufferproc = ::std::option::Option; pub type objobjproc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> ::std::os::raw::c_int, >; pub type visitproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; pub type traverseproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: visitproc, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyNumberMethods { pub nb_add: binaryfunc, pub nb_subtract: binaryfunc, pub nb_multiply: binaryfunc, pub nb_remainder: binaryfunc, pub nb_divmod: binaryfunc, pub nb_power: ternaryfunc, pub nb_negative: unaryfunc, pub nb_positive: unaryfunc, pub nb_absolute: unaryfunc, pub nb_bool: inquiry, pub nb_invert: unaryfunc, pub nb_lshift: binaryfunc, pub nb_rshift: binaryfunc, pub nb_and: binaryfunc, pub nb_xor: binaryfunc, pub nb_or: binaryfunc, pub nb_int: unaryfunc, pub nb_reserved: *mut ::std::os::raw::c_void, pub nb_float: unaryfunc, pub nb_inplace_add: binaryfunc, pub nb_inplace_subtract: binaryfunc, pub nb_inplace_multiply: binaryfunc, pub nb_inplace_remainder: binaryfunc, pub nb_inplace_power: ternaryfunc, pub nb_inplace_lshift: binaryfunc, pub nb_inplace_rshift: binaryfunc, pub nb_inplace_and: binaryfunc, pub nb_inplace_xor: binaryfunc, pub nb_inplace_or: binaryfunc, pub nb_floor_divide: binaryfunc, pub nb_true_divide: binaryfunc, pub nb_inplace_floor_divide: binaryfunc, pub nb_inplace_true_divide: binaryfunc, pub nb_index: unaryfunc, } impl Default for PyNumberMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PySequenceMethods { pub sq_length: lenfunc, pub sq_concat: binaryfunc, pub sq_repeat: ssizeargfunc, pub sq_item: ssizeargfunc, pub was_sq_slice: *mut ::std::os::raw::c_void, pub sq_ass_item: ssizeobjargproc, pub was_sq_ass_slice: *mut ::std::os::raw::c_void, pub sq_contains: objobjproc, pub sq_inplace_concat: binaryfunc, pub sq_inplace_repeat: ssizeargfunc, } impl Default for PySequenceMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyMappingMethods { pub mp_length: lenfunc, pub mp_subscript: binaryfunc, pub mp_ass_subscript: objobjargproc, } impl Default for PyMappingMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyBufferProcs { pub bf_getbuffer: getbufferproc, pub bf_releasebuffer: releasebufferproc, } impl Default for PyBufferProcs { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type freefunc = ::std::option::Option; pub type destructor = ::std::option::Option; pub type printfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut FILE, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >; pub type getattrfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_char) -> *mut PyObject, >; pub type getattrofunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject, >; pub type setattrfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_char, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type setattrofunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type reprfunc = ::std::option::Option *mut PyObject>; pub type hashfunc = ::std::option::Option Py_hash_t>; pub type richcmpfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: ::std::os::raw::c_int, ) -> *mut PyObject, >; pub type getiterfunc = ::std::option::Option *mut PyObject>; pub type iternextfunc = ::std::option::Option *mut PyObject>; pub type descrgetfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> *mut PyObject, >; pub type descrsetfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type initproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type newfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut _typeobject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> *mut PyObject, >; pub type allocfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut _typeobject, arg2: Py_ssize_t) -> *mut PyObject, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _typeobject { pub ob_base: PyVarObject, pub tp_name: *const ::std::os::raw::c_char, pub tp_basicsize: Py_ssize_t, pub tp_itemsize: Py_ssize_t, pub tp_dealloc: destructor, pub tp_print: printfunc, pub tp_getattr: getattrfunc, pub tp_setattr: setattrfunc, pub tp_reserved: *mut ::std::os::raw::c_void, pub tp_repr: reprfunc, pub tp_as_number: *mut PyNumberMethods, pub tp_as_sequence: *mut PySequenceMethods, pub tp_as_mapping: *mut PyMappingMethods, pub tp_hash: hashfunc, pub tp_call: ternaryfunc, pub tp_str: reprfunc, pub tp_getattro: getattrofunc, pub tp_setattro: setattrofunc, pub tp_as_buffer: *mut PyBufferProcs, pub tp_flags: ::std::os::raw::c_ulong, pub tp_doc: *const ::std::os::raw::c_char, pub tp_traverse: traverseproc, pub tp_clear: inquiry, pub tp_richcompare: richcmpfunc, pub tp_weaklistoffset: Py_ssize_t, pub tp_iter: getiterfunc, pub tp_iternext: iternextfunc, pub tp_methods: *mut PyMethodDef, pub tp_members: *mut PyMemberDef, pub tp_getset: *mut PyGetSetDef, pub tp_base: *mut _typeobject, pub tp_dict: *mut PyObject, pub tp_descr_get: descrgetfunc, pub tp_descr_set: descrsetfunc, pub tp_dictoffset: Py_ssize_t, pub tp_init: initproc, pub tp_alloc: allocfunc, pub tp_new: newfunc, pub tp_free: freefunc, pub tp_is_gc: inquiry, pub tp_bases: *mut PyObject, pub tp_mro: *mut PyObject, pub tp_cache: *mut PyObject, pub tp_subclasses: *mut PyObject, pub tp_weaklist: *mut PyObject, pub tp_del: destructor, pub tp_version_tag: ::std::os::raw::c_uint, pub tp_finalize: destructor, } impl Default for _typeobject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyTypeObject = _typeobject; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyBytesObject { pub ob_base: PyVarObject, pub ob_shash: Py_hash_t, pub ob_sval: [::std::os::raw::c_char; 1usize], } impl Default for PyBytesObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type Py_UCS4 = ::std::os::raw::c_uint; pub type Py_UCS2 = ::std::os::raw::c_ushort; pub type Py_UCS1 = ::std::os::raw::c_uchar; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyASCIIObject { pub ob_base: PyObject, pub length: Py_ssize_t, pub hash: Py_hash_t, pub state: PyASCIIObject__bindgen_ty_1, pub wstr: *mut wchar_t, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct PyASCIIObject__bindgen_ty_1 { pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u8>, pub __bindgen_align: [u32; 0usize], } impl PyASCIIObject__bindgen_ty_1 { #[inline] pub fn interned(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) } } #[inline] pub fn set_interned(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(0usize, 2u8, val as u64) } } #[inline] pub fn kind(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 3u8) as u32) } } #[inline] pub fn set_kind(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(2usize, 3u8, val as u64) } } #[inline] pub fn compact(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } } #[inline] pub fn set_compact(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(5usize, 1u8, val as u64) } } #[inline] pub fn ascii(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } } #[inline] pub fn set_ascii(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(6usize, 1u8, val as u64) } } #[inline] pub fn ready(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } } #[inline] pub fn set_ready(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(7usize, 1u8, val as u64) } } #[inline] pub fn new_bitfield_1( interned: ::std::os::raw::c_uint, kind: ::std::os::raw::c_uint, compact: ::std::os::raw::c_uint, ascii: ::std::os::raw::c_uint, ready: ::std::os::raw::c_uint, ) -> __BindgenBitfieldUnit<[u8; 4usize], u8> { let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u8> = Default::default(); __bindgen_bitfield_unit.set(0usize, 2u8, { let interned: u32 = unsafe { ::std::mem::transmute(interned) }; interned as u64 }); __bindgen_bitfield_unit.set(2usize, 3u8, { let kind: u32 = unsafe { ::std::mem::transmute(kind) }; kind as u64 }); __bindgen_bitfield_unit.set(5usize, 1u8, { let compact: u32 = unsafe { ::std::mem::transmute(compact) }; compact as u64 }); __bindgen_bitfield_unit.set(6usize, 1u8, { let ascii: u32 = unsafe { ::std::mem::transmute(ascii) }; ascii as u64 }); __bindgen_bitfield_unit.set(7usize, 1u8, { let ready: u32 = unsafe { ::std::mem::transmute(ready) }; ready as u64 }); __bindgen_bitfield_unit } } impl Default for PyASCIIObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyCompactUnicodeObject { pub _base: PyASCIIObject, pub utf8_length: Py_ssize_t, pub utf8: *mut ::std::os::raw::c_char, pub wstr_length: Py_ssize_t, } impl Default for PyCompactUnicodeObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct PyUnicodeObject { pub _base: PyCompactUnicodeObject, pub data: PyUnicodeObject__bindgen_ty_1, } #[repr(C)] #[derive(Copy, Clone)] pub union PyUnicodeObject__bindgen_ty_1 { pub any: *mut ::std::os::raw::c_void, pub latin1: *mut Py_UCS1, pub ucs2: *mut Py_UCS2, pub ucs4: *mut Py_UCS4, _bindgen_union_align: u64, } impl Default for PyUnicodeObject__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for PyUnicodeObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyLongObject = _longobject; pub type digit = u32; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _longobject { pub ob_base: PyVarObject, pub ob_digit: [digit; 1usize], } impl Default for _longobject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyFloatObject { pub ob_base: PyObject, pub ob_fval: f64, } impl Default for PyFloatObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyTupleObject { pub ob_base: PyVarObject, pub ob_item: [*mut PyObject; 1usize], } impl Default for PyTupleObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyListObject { pub ob_base: PyVarObject, pub ob_item: *mut *mut PyObject, pub allocated: Py_ssize_t, } impl Default for PyListObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyDictKeysObject = _dictkeysobject; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyDictObject { pub ob_base: PyObject, pub ma_used: Py_ssize_t, pub ma_keys: *mut PyDictKeysObject, pub ma_values: *mut *mut PyObject, } impl Default for PyDictObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyCFunction = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyMethodDef { pub ml_name: *const ::std::os::raw::c_char, pub ml_meth: PyCFunction, pub ml_flags: ::std::os::raw::c_int, pub ml_doc: *const ::std::os::raw::c_char, } impl Default for PyMethodDef { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _is { pub next: *mut _is, pub tstate_head: *mut _ts, pub modules: *mut PyObject, pub modules_by_index: *mut PyObject, pub sysdict: *mut PyObject, pub builtins: *mut PyObject, pub importlib: *mut PyObject, pub codec_search_path: *mut PyObject, pub codec_search_cache: *mut PyObject, pub codec_error_registry: *mut PyObject, pub codecs_initialized: ::std::os::raw::c_int, pub fscodec_initialized: ::std::os::raw::c_int, pub dlopenflags: ::std::os::raw::c_int, pub builtins_copy: *mut PyObject, } impl Default for _is { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyInterpreterState = _is; pub type Py_tracefunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut _frame, arg3: ::std::os::raw::c_int, arg4: *mut PyObject, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _ts { pub prev: *mut _ts, pub next: *mut _ts, pub interp: *mut PyInterpreterState, pub frame: *mut _frame, pub recursion_depth: ::std::os::raw::c_int, pub overflowed: ::std::os::raw::c_char, pub recursion_critical: ::std::os::raw::c_char, pub tracing: ::std::os::raw::c_int, pub use_tracing: ::std::os::raw::c_int, pub c_profilefunc: Py_tracefunc, pub c_tracefunc: Py_tracefunc, pub c_profileobj: *mut PyObject, pub c_traceobj: *mut PyObject, pub curexc_type: *mut PyObject, pub curexc_value: *mut PyObject, pub curexc_traceback: *mut PyObject, pub exc_type: *mut PyObject, pub exc_value: *mut PyObject, pub exc_traceback: *mut PyObject, pub dict: *mut PyObject, pub gilstate_counter: ::std::os::raw::c_int, pub async_exc: *mut PyObject, pub thread_id: ::std::os::raw::c_long, pub trash_delete_nesting: ::std::os::raw::c_int, pub trash_delete_later: *mut PyObject, pub on_delete: ::std::option::Option, pub on_delete_data: *mut ::std::os::raw::c_void, } impl Default for _ts { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyThreadState = _ts; pub type getter = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_void) -> *mut PyObject, >; pub type setter = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyGetSetDef { pub name: *mut ::std::os::raw::c_char, pub get: getter, pub set: setter, pub doc: *mut ::std::os::raw::c_char, pub closure: *mut ::std::os::raw::c_void, } impl Default for PyGetSetDef { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyMemberDef { _unused: [u8; 0], } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyCodeObject { pub ob_base: PyObject, pub co_argcount: ::std::os::raw::c_int, pub co_kwonlyargcount: ::std::os::raw::c_int, pub co_nlocals: ::std::os::raw::c_int, pub co_stacksize: ::std::os::raw::c_int, pub co_flags: ::std::os::raw::c_int, pub co_code: *mut PyObject, pub co_consts: *mut PyObject, pub co_names: *mut PyObject, pub co_varnames: *mut PyObject, pub co_freevars: *mut PyObject, pub co_cellvars: *mut PyObject, pub co_cell2arg: *mut ::std::os::raw::c_uchar, pub co_filename: *mut PyObject, pub co_name: *mut PyObject, pub co_firstlineno: ::std::os::raw::c_int, pub co_lnotab: *mut PyObject, pub co_zombieframe: *mut ::std::os::raw::c_void, pub co_weakreflist: *mut PyObject, } impl Default for PyCodeObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct PyTryBlock { pub b_type: ::std::os::raw::c_int, pub b_handler: ::std::os::raw::c_int, pub b_level: ::std::os::raw::c_int, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _frame { pub ob_base: PyVarObject, pub f_back: *mut _frame, pub f_code: *mut PyCodeObject, pub f_builtins: *mut PyObject, pub f_globals: *mut PyObject, pub f_locals: *mut PyObject, pub f_valuestack: *mut *mut PyObject, pub f_stacktop: *mut *mut PyObject, pub f_trace: *mut PyObject, pub f_exc_type: *mut PyObject, pub f_exc_value: *mut PyObject, pub f_exc_traceback: *mut PyObject, pub f_gen: *mut PyObject, pub f_lasti: ::std::os::raw::c_int, pub f_lineno: ::std::os::raw::c_int, pub f_iblock: ::std::os::raw::c_int, pub f_executing: ::std::os::raw::c_char, pub f_blockstack: [PyTryBlock; 20usize], pub f_localsplus: [*mut PyObject; 1usize], } impl Default for _frame { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyFrameObject = _frame; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _dictkeysobject { pub _address: u8, } ================================================ FILE: src/python_bindings/v3_5_5.rs ================================================ // Generated bindings for python v3.5.5 #![allow(dead_code)] #![allow(non_upper_case_globals)] #![allow(non_camel_case_types)] #![allow(non_snake_case)] #![allow(clippy::useless_transmute)] #![allow(clippy::default_trait_access)] #![allow(clippy::cast_lossless)] #![allow(clippy::trivially_copy_pass_by_ref)] #![allow(clippy::upper_case_acronyms)] /* automatically generated by rust-bindgen */ #[repr(C)] #[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] pub struct __BindgenBitfieldUnit where Storage: AsRef<[u8]> + AsMut<[u8]>, { storage: Storage, align: [Align; 0], } impl __BindgenBitfieldUnit where Storage: AsRef<[u8]> + AsMut<[u8]>, { #[inline] pub fn new(storage: Storage) -> Self { Self { storage, align: [] } } #[inline] pub fn get_bit(&self, index: usize) -> bool { debug_assert!(index / 8 < self.storage.as_ref().len()); let byte_index = index / 8; let byte = self.storage.as_ref()[byte_index]; let bit_index = index % 8; let mask = 1 << bit_index; byte & mask == mask } #[inline] pub fn set_bit(&mut self, index: usize, val: bool) { debug_assert!(index / 8 < self.storage.as_ref().len()); let byte_index = index / 8; let byte = &mut self.storage.as_mut()[byte_index]; let bit_index = index % 8; let mask = 1 << bit_index; if val { *byte |= mask; } else { *byte &= !mask; } } #[inline] pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); let mut val = 0; for i in 0..(bit_width as usize) { if self.get_bit(i + bit_offset) { val |= 1 << i; } } val } #[inline] pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); for i in 0..(bit_width as usize) { let mask = 1 << i; let val_bit_is_set = val & mask == mask; self.set_bit(i + bit_offset, val_bit_is_set); } } } pub type __int64_t = ::std::os::raw::c_longlong; pub type __darwin_wchar_t = ::std::os::raw::c_int; pub type __darwin_ssize_t = ::std::os::raw::c_long; pub type __darwin_off_t = __int64_t; pub type fpos_t = __darwin_off_t; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct __sbuf { pub _base: *mut ::std::os::raw::c_uchar, pub _size: ::std::os::raw::c_int, } impl Default for __sbuf { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct __sFILEX { _unused: [u8; 0], } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct __sFILE { pub _p: *mut ::std::os::raw::c_uchar, pub _r: ::std::os::raw::c_int, pub _w: ::std::os::raw::c_int, pub _flags: ::std::os::raw::c_short, pub _file: ::std::os::raw::c_short, pub _bf: __sbuf, pub _lbfsize: ::std::os::raw::c_int, pub _cookie: *mut ::std::os::raw::c_void, pub _close: ::std::option::Option< unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, >, pub _read: ::std::option::Option< unsafe extern "C" fn( arg1: *mut ::std::os::raw::c_void, arg2: *mut ::std::os::raw::c_char, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >, pub _seek: ::std::option::Option< unsafe extern "C" fn( arg1: *mut ::std::os::raw::c_void, arg2: fpos_t, arg3: ::std::os::raw::c_int, ) -> fpos_t, >, pub _write: ::std::option::Option< unsafe extern "C" fn( arg1: *mut ::std::os::raw::c_void, arg2: *const ::std::os::raw::c_char, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >, pub _ub: __sbuf, pub _extra: *mut __sFILEX, pub _ur: ::std::os::raw::c_int, pub _ubuf: [::std::os::raw::c_uchar; 3usize], pub _nbuf: [::std::os::raw::c_uchar; 1usize], pub _lb: __sbuf, pub _blksize: ::std::os::raw::c_int, pub _offset: fpos_t, } impl Default for __sFILE { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type FILE = __sFILE; pub type wchar_t = __darwin_wchar_t; pub type Py_ssize_t = isize; pub type Py_hash_t = Py_ssize_t; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _object { pub ob_refcnt: Py_ssize_t, pub ob_type: *mut _typeobject, } impl Default for _object { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyObject = _object; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyVarObject { pub ob_base: PyObject, pub ob_size: Py_ssize_t, } impl Default for PyVarObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type unaryfunc = ::std::option::Option *mut PyObject>; pub type binaryfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject, >; pub type ternaryfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> *mut PyObject, >; pub type inquiry = ::std::option::Option ::std::os::raw::c_int>; pub type lenfunc = ::std::option::Option Py_ssize_t>; pub type ssizeargfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: Py_ssize_t) -> *mut PyObject, >; pub type ssizeobjargproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: Py_ssize_t, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type objobjargproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct bufferinfo { pub buf: *mut ::std::os::raw::c_void, pub obj: *mut PyObject, pub len: Py_ssize_t, pub itemsize: Py_ssize_t, pub readonly: ::std::os::raw::c_int, pub ndim: ::std::os::raw::c_int, pub format: *mut ::std::os::raw::c_char, pub shape: *mut Py_ssize_t, pub strides: *mut Py_ssize_t, pub suboffsets: *mut Py_ssize_t, pub internal: *mut ::std::os::raw::c_void, } impl Default for bufferinfo { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type Py_buffer = bufferinfo; pub type getbufferproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut Py_buffer, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >; pub type releasebufferproc = ::std::option::Option; pub type objobjproc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> ::std::os::raw::c_int, >; pub type visitproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; pub type traverseproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: visitproc, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyNumberMethods { pub nb_add: binaryfunc, pub nb_subtract: binaryfunc, pub nb_multiply: binaryfunc, pub nb_remainder: binaryfunc, pub nb_divmod: binaryfunc, pub nb_power: ternaryfunc, pub nb_negative: unaryfunc, pub nb_positive: unaryfunc, pub nb_absolute: unaryfunc, pub nb_bool: inquiry, pub nb_invert: unaryfunc, pub nb_lshift: binaryfunc, pub nb_rshift: binaryfunc, pub nb_and: binaryfunc, pub nb_xor: binaryfunc, pub nb_or: binaryfunc, pub nb_int: unaryfunc, pub nb_reserved: *mut ::std::os::raw::c_void, pub nb_float: unaryfunc, pub nb_inplace_add: binaryfunc, pub nb_inplace_subtract: binaryfunc, pub nb_inplace_multiply: binaryfunc, pub nb_inplace_remainder: binaryfunc, pub nb_inplace_power: ternaryfunc, pub nb_inplace_lshift: binaryfunc, pub nb_inplace_rshift: binaryfunc, pub nb_inplace_and: binaryfunc, pub nb_inplace_xor: binaryfunc, pub nb_inplace_or: binaryfunc, pub nb_floor_divide: binaryfunc, pub nb_true_divide: binaryfunc, pub nb_inplace_floor_divide: binaryfunc, pub nb_inplace_true_divide: binaryfunc, pub nb_index: unaryfunc, pub nb_matrix_multiply: binaryfunc, pub nb_inplace_matrix_multiply: binaryfunc, } impl Default for PyNumberMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PySequenceMethods { pub sq_length: lenfunc, pub sq_concat: binaryfunc, pub sq_repeat: ssizeargfunc, pub sq_item: ssizeargfunc, pub was_sq_slice: *mut ::std::os::raw::c_void, pub sq_ass_item: ssizeobjargproc, pub was_sq_ass_slice: *mut ::std::os::raw::c_void, pub sq_contains: objobjproc, pub sq_inplace_concat: binaryfunc, pub sq_inplace_repeat: ssizeargfunc, } impl Default for PySequenceMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyMappingMethods { pub mp_length: lenfunc, pub mp_subscript: binaryfunc, pub mp_ass_subscript: objobjargproc, } impl Default for PyMappingMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyAsyncMethods { pub am_await: unaryfunc, pub am_aiter: unaryfunc, pub am_anext: unaryfunc, } impl Default for PyAsyncMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyBufferProcs { pub bf_getbuffer: getbufferproc, pub bf_releasebuffer: releasebufferproc, } impl Default for PyBufferProcs { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type freefunc = ::std::option::Option; pub type destructor = ::std::option::Option; pub type printfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut FILE, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >; pub type getattrfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_char) -> *mut PyObject, >; pub type getattrofunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject, >; pub type setattrfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_char, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type setattrofunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type reprfunc = ::std::option::Option *mut PyObject>; pub type hashfunc = ::std::option::Option Py_hash_t>; pub type richcmpfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: ::std::os::raw::c_int, ) -> *mut PyObject, >; pub type getiterfunc = ::std::option::Option *mut PyObject>; pub type iternextfunc = ::std::option::Option *mut PyObject>; pub type descrgetfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> *mut PyObject, >; pub type descrsetfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type initproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type newfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut _typeobject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> *mut PyObject, >; pub type allocfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut _typeobject, arg2: Py_ssize_t) -> *mut PyObject, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _typeobject { pub ob_base: PyVarObject, pub tp_name: *const ::std::os::raw::c_char, pub tp_basicsize: Py_ssize_t, pub tp_itemsize: Py_ssize_t, pub tp_dealloc: destructor, pub tp_print: printfunc, pub tp_getattr: getattrfunc, pub tp_setattr: setattrfunc, pub tp_as_async: *mut PyAsyncMethods, pub tp_repr: reprfunc, pub tp_as_number: *mut PyNumberMethods, pub tp_as_sequence: *mut PySequenceMethods, pub tp_as_mapping: *mut PyMappingMethods, pub tp_hash: hashfunc, pub tp_call: ternaryfunc, pub tp_str: reprfunc, pub tp_getattro: getattrofunc, pub tp_setattro: setattrofunc, pub tp_as_buffer: *mut PyBufferProcs, pub tp_flags: ::std::os::raw::c_ulong, pub tp_doc: *const ::std::os::raw::c_char, pub tp_traverse: traverseproc, pub tp_clear: inquiry, pub tp_richcompare: richcmpfunc, pub tp_weaklistoffset: Py_ssize_t, pub tp_iter: getiterfunc, pub tp_iternext: iternextfunc, pub tp_methods: *mut PyMethodDef, pub tp_members: *mut PyMemberDef, pub tp_getset: *mut PyGetSetDef, pub tp_base: *mut _typeobject, pub tp_dict: *mut PyObject, pub tp_descr_get: descrgetfunc, pub tp_descr_set: descrsetfunc, pub tp_dictoffset: Py_ssize_t, pub tp_init: initproc, pub tp_alloc: allocfunc, pub tp_new: newfunc, pub tp_free: freefunc, pub tp_is_gc: inquiry, pub tp_bases: *mut PyObject, pub tp_mro: *mut PyObject, pub tp_cache: *mut PyObject, pub tp_subclasses: *mut PyObject, pub tp_weaklist: *mut PyObject, pub tp_del: destructor, pub tp_version_tag: ::std::os::raw::c_uint, pub tp_finalize: destructor, } impl Default for _typeobject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyTypeObject = _typeobject; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyBytesObject { pub ob_base: PyVarObject, pub ob_shash: Py_hash_t, pub ob_sval: [::std::os::raw::c_char; 1usize], } impl Default for PyBytesObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type Py_UCS4 = ::std::os::raw::c_uint; pub type Py_UCS2 = ::std::os::raw::c_ushort; pub type Py_UCS1 = ::std::os::raw::c_uchar; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyASCIIObject { pub ob_base: PyObject, pub length: Py_ssize_t, pub hash: Py_hash_t, pub state: PyASCIIObject__bindgen_ty_1, pub wstr: *mut wchar_t, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct PyASCIIObject__bindgen_ty_1 { pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u8>, pub __bindgen_align: [u32; 0usize], } impl PyASCIIObject__bindgen_ty_1 { #[inline] pub fn interned(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) } } #[inline] pub fn set_interned(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(0usize, 2u8, val as u64) } } #[inline] pub fn kind(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 3u8) as u32) } } #[inline] pub fn set_kind(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(2usize, 3u8, val as u64) } } #[inline] pub fn compact(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } } #[inline] pub fn set_compact(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(5usize, 1u8, val as u64) } } #[inline] pub fn ascii(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } } #[inline] pub fn set_ascii(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(6usize, 1u8, val as u64) } } #[inline] pub fn ready(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } } #[inline] pub fn set_ready(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(7usize, 1u8, val as u64) } } #[inline] pub fn new_bitfield_1( interned: ::std::os::raw::c_uint, kind: ::std::os::raw::c_uint, compact: ::std::os::raw::c_uint, ascii: ::std::os::raw::c_uint, ready: ::std::os::raw::c_uint, ) -> __BindgenBitfieldUnit<[u8; 4usize], u8> { let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u8> = Default::default(); __bindgen_bitfield_unit.set(0usize, 2u8, { let interned: u32 = unsafe { ::std::mem::transmute(interned) }; interned as u64 }); __bindgen_bitfield_unit.set(2usize, 3u8, { let kind: u32 = unsafe { ::std::mem::transmute(kind) }; kind as u64 }); __bindgen_bitfield_unit.set(5usize, 1u8, { let compact: u32 = unsafe { ::std::mem::transmute(compact) }; compact as u64 }); __bindgen_bitfield_unit.set(6usize, 1u8, { let ascii: u32 = unsafe { ::std::mem::transmute(ascii) }; ascii as u64 }); __bindgen_bitfield_unit.set(7usize, 1u8, { let ready: u32 = unsafe { ::std::mem::transmute(ready) }; ready as u64 }); __bindgen_bitfield_unit } } impl Default for PyASCIIObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyCompactUnicodeObject { pub _base: PyASCIIObject, pub utf8_length: Py_ssize_t, pub utf8: *mut ::std::os::raw::c_char, pub wstr_length: Py_ssize_t, } impl Default for PyCompactUnicodeObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct PyUnicodeObject { pub _base: PyCompactUnicodeObject, pub data: PyUnicodeObject__bindgen_ty_1, } #[repr(C)] #[derive(Copy, Clone)] pub union PyUnicodeObject__bindgen_ty_1 { pub any: *mut ::std::os::raw::c_void, pub latin1: *mut Py_UCS1, pub ucs2: *mut Py_UCS2, pub ucs4: *mut Py_UCS4, _bindgen_union_align: u64, } impl Default for PyUnicodeObject__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for PyUnicodeObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyLongObject = _longobject; pub type digit = u32; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _longobject { pub ob_base: PyVarObject, pub ob_digit: [digit; 1usize], } impl Default for _longobject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyFloatObject { pub ob_base: PyObject, pub ob_fval: f64, } impl Default for PyFloatObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyTupleObject { pub ob_base: PyVarObject, pub ob_item: [*mut PyObject; 1usize], } impl Default for PyTupleObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyListObject { pub ob_base: PyVarObject, pub ob_item: *mut *mut PyObject, pub allocated: Py_ssize_t, } impl Default for PyListObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyDictKeysObject = _dictkeysobject; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyDictObject { pub ob_base: PyObject, pub ma_used: Py_ssize_t, pub ma_keys: *mut PyDictKeysObject, pub ma_values: *mut *mut PyObject, } impl Default for PyDictObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyCFunction = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyMethodDef { pub ml_name: *const ::std::os::raw::c_char, pub ml_meth: PyCFunction, pub ml_flags: ::std::os::raw::c_int, pub ml_doc: *const ::std::os::raw::c_char, } impl Default for PyMethodDef { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _is { pub next: *mut _is, pub tstate_head: *mut _ts, pub modules: *mut PyObject, pub modules_by_index: *mut PyObject, pub sysdict: *mut PyObject, pub builtins: *mut PyObject, pub importlib: *mut PyObject, pub codec_search_path: *mut PyObject, pub codec_search_cache: *mut PyObject, pub codec_error_registry: *mut PyObject, pub codecs_initialized: ::std::os::raw::c_int, pub fscodec_initialized: ::std::os::raw::c_int, pub dlopenflags: ::std::os::raw::c_int, pub builtins_copy: *mut PyObject, } impl Default for _is { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyInterpreterState = _is; pub type Py_tracefunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut _frame, arg3: ::std::os::raw::c_int, arg4: *mut PyObject, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _ts { pub prev: *mut _ts, pub next: *mut _ts, pub interp: *mut PyInterpreterState, pub frame: *mut _frame, pub recursion_depth: ::std::os::raw::c_int, pub overflowed: ::std::os::raw::c_char, pub recursion_critical: ::std::os::raw::c_char, pub tracing: ::std::os::raw::c_int, pub use_tracing: ::std::os::raw::c_int, pub c_profilefunc: Py_tracefunc, pub c_tracefunc: Py_tracefunc, pub c_profileobj: *mut PyObject, pub c_traceobj: *mut PyObject, pub curexc_type: *mut PyObject, pub curexc_value: *mut PyObject, pub curexc_traceback: *mut PyObject, pub exc_type: *mut PyObject, pub exc_value: *mut PyObject, pub exc_traceback: *mut PyObject, pub dict: *mut PyObject, pub gilstate_counter: ::std::os::raw::c_int, pub async_exc: *mut PyObject, pub thread_id: ::std::os::raw::c_long, pub trash_delete_nesting: ::std::os::raw::c_int, pub trash_delete_later: *mut PyObject, pub on_delete: ::std::option::Option, pub on_delete_data: *mut ::std::os::raw::c_void, pub coroutine_wrapper: *mut PyObject, pub in_coroutine_wrapper: ::std::os::raw::c_int, } impl Default for _ts { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyThreadState = _ts; pub type getter = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_void) -> *mut PyObject, >; pub type setter = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyGetSetDef { pub name: *mut ::std::os::raw::c_char, pub get: getter, pub set: setter, pub doc: *mut ::std::os::raw::c_char, pub closure: *mut ::std::os::raw::c_void, } impl Default for PyGetSetDef { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyMemberDef { _unused: [u8; 0], } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyCodeObject { pub ob_base: PyObject, pub co_argcount: ::std::os::raw::c_int, pub co_kwonlyargcount: ::std::os::raw::c_int, pub co_nlocals: ::std::os::raw::c_int, pub co_stacksize: ::std::os::raw::c_int, pub co_flags: ::std::os::raw::c_int, pub co_code: *mut PyObject, pub co_consts: *mut PyObject, pub co_names: *mut PyObject, pub co_varnames: *mut PyObject, pub co_freevars: *mut PyObject, pub co_cellvars: *mut PyObject, pub co_cell2arg: *mut ::std::os::raw::c_uchar, pub co_filename: *mut PyObject, pub co_name: *mut PyObject, pub co_firstlineno: ::std::os::raw::c_int, pub co_lnotab: *mut PyObject, pub co_zombieframe: *mut ::std::os::raw::c_void, pub co_weakreflist: *mut PyObject, } impl Default for PyCodeObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct PyTryBlock { pub b_type: ::std::os::raw::c_int, pub b_handler: ::std::os::raw::c_int, pub b_level: ::std::os::raw::c_int, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _frame { pub ob_base: PyVarObject, pub f_back: *mut _frame, pub f_code: *mut PyCodeObject, pub f_builtins: *mut PyObject, pub f_globals: *mut PyObject, pub f_locals: *mut PyObject, pub f_valuestack: *mut *mut PyObject, pub f_stacktop: *mut *mut PyObject, pub f_trace: *mut PyObject, pub f_exc_type: *mut PyObject, pub f_exc_value: *mut PyObject, pub f_exc_traceback: *mut PyObject, pub f_gen: *mut PyObject, pub f_lasti: ::std::os::raw::c_int, pub f_lineno: ::std::os::raw::c_int, pub f_iblock: ::std::os::raw::c_int, pub f_executing: ::std::os::raw::c_char, pub f_blockstack: [PyTryBlock; 20usize], pub f_localsplus: [*mut PyObject; 1usize], } impl Default for _frame { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyFrameObject = _frame; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyDictKeyEntry { pub me_hash: Py_hash_t, pub me_key: *mut PyObject, pub me_value: *mut PyObject, } impl Default for PyDictKeyEntry { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type dict_lookup_func = ::std::option::Option< unsafe extern "C" fn( mp: *mut PyDictObject, key: *mut PyObject, hash: Py_hash_t, value_addr: *mut *mut *mut PyObject, ) -> *mut PyDictKeyEntry, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _dictkeysobject { pub dk_refcnt: Py_ssize_t, pub dk_size: Py_ssize_t, pub dk_lookup: dict_lookup_func, pub dk_usable: Py_ssize_t, pub dk_entries: [PyDictKeyEntry; 1usize], } impl Default for _dictkeysobject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } ================================================ FILE: src/python_bindings/v3_6_6.rs ================================================ // Generated bindings for python v3.6.6 #![allow(dead_code)] #![allow(non_upper_case_globals)] #![allow(non_camel_case_types)] #![allow(non_snake_case)] #![allow(clippy::useless_transmute)] #![allow(clippy::default_trait_access)] #![allow(clippy::cast_lossless)] #![allow(clippy::trivially_copy_pass_by_ref)] #![allow(clippy::upper_case_acronyms)] /* automatically generated by rust-bindgen */ #[repr(C)] #[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] pub struct __BindgenBitfieldUnit where Storage: AsRef<[u8]> + AsMut<[u8]>, { storage: Storage, align: [Align; 0], } impl __BindgenBitfieldUnit where Storage: AsRef<[u8]> + AsMut<[u8]>, { #[inline] pub fn new(storage: Storage) -> Self { Self { storage, align: [] } } #[inline] pub fn get_bit(&self, index: usize) -> bool { debug_assert!(index / 8 < self.storage.as_ref().len()); let byte_index = index / 8; let byte = self.storage.as_ref()[byte_index]; let bit_index = index % 8; let mask = 1 << bit_index; byte & mask == mask } #[inline] pub fn set_bit(&mut self, index: usize, val: bool) { debug_assert!(index / 8 < self.storage.as_ref().len()); let byte_index = index / 8; let byte = &mut self.storage.as_mut()[byte_index]; let bit_index = index % 8; let mask = 1 << bit_index; if val { *byte |= mask; } else { *byte &= !mask; } } #[inline] pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); let mut val = 0; for i in 0..(bit_width as usize) { if self.get_bit(i + bit_offset) { val |= 1 << i; } } val } #[inline] pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); for i in 0..(bit_width as usize) { let mask = 1 << i; let val_bit_is_set = val & mask == mask; self.set_bit(i + bit_offset, val_bit_is_set); } } } pub type __int64_t = ::std::os::raw::c_longlong; pub type __darwin_wchar_t = ::std::os::raw::c_int; pub type __darwin_ssize_t = ::std::os::raw::c_long; pub type __darwin_off_t = __int64_t; pub type fpos_t = __darwin_off_t; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct __sbuf { pub _base: *mut ::std::os::raw::c_uchar, pub _size: ::std::os::raw::c_int, } impl Default for __sbuf { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct __sFILEX { _unused: [u8; 0], } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct __sFILE { pub _p: *mut ::std::os::raw::c_uchar, pub _r: ::std::os::raw::c_int, pub _w: ::std::os::raw::c_int, pub _flags: ::std::os::raw::c_short, pub _file: ::std::os::raw::c_short, pub _bf: __sbuf, pub _lbfsize: ::std::os::raw::c_int, pub _cookie: *mut ::std::os::raw::c_void, pub _close: ::std::option::Option< unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, >, pub _read: ::std::option::Option< unsafe extern "C" fn( arg1: *mut ::std::os::raw::c_void, arg2: *mut ::std::os::raw::c_char, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >, pub _seek: ::std::option::Option< unsafe extern "C" fn( arg1: *mut ::std::os::raw::c_void, arg2: fpos_t, arg3: ::std::os::raw::c_int, ) -> fpos_t, >, pub _write: ::std::option::Option< unsafe extern "C" fn( arg1: *mut ::std::os::raw::c_void, arg2: *const ::std::os::raw::c_char, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >, pub _ub: __sbuf, pub _extra: *mut __sFILEX, pub _ur: ::std::os::raw::c_int, pub _ubuf: [::std::os::raw::c_uchar; 3usize], pub _nbuf: [::std::os::raw::c_uchar; 1usize], pub _lb: __sbuf, pub _blksize: ::std::os::raw::c_int, pub _offset: fpos_t, } impl Default for __sFILE { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type FILE = __sFILE; pub type wchar_t = __darwin_wchar_t; pub type Py_ssize_t = isize; pub type Py_hash_t = Py_ssize_t; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _object { pub ob_refcnt: Py_ssize_t, pub ob_type: *mut _typeobject, } impl Default for _object { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyObject = _object; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyVarObject { pub ob_base: PyObject, pub ob_size: Py_ssize_t, } impl Default for PyVarObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type unaryfunc = ::std::option::Option *mut PyObject>; pub type binaryfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject, >; pub type ternaryfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> *mut PyObject, >; pub type inquiry = ::std::option::Option ::std::os::raw::c_int>; pub type lenfunc = ::std::option::Option Py_ssize_t>; pub type ssizeargfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: Py_ssize_t) -> *mut PyObject, >; pub type ssizeobjargproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: Py_ssize_t, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type objobjargproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct bufferinfo { pub buf: *mut ::std::os::raw::c_void, pub obj: *mut PyObject, pub len: Py_ssize_t, pub itemsize: Py_ssize_t, pub readonly: ::std::os::raw::c_int, pub ndim: ::std::os::raw::c_int, pub format: *mut ::std::os::raw::c_char, pub shape: *mut Py_ssize_t, pub strides: *mut Py_ssize_t, pub suboffsets: *mut Py_ssize_t, pub internal: *mut ::std::os::raw::c_void, } impl Default for bufferinfo { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type Py_buffer = bufferinfo; pub type getbufferproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut Py_buffer, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >; pub type releasebufferproc = ::std::option::Option; pub type objobjproc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> ::std::os::raw::c_int, >; pub type visitproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; pub type traverseproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: visitproc, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyNumberMethods { pub nb_add: binaryfunc, pub nb_subtract: binaryfunc, pub nb_multiply: binaryfunc, pub nb_remainder: binaryfunc, pub nb_divmod: binaryfunc, pub nb_power: ternaryfunc, pub nb_negative: unaryfunc, pub nb_positive: unaryfunc, pub nb_absolute: unaryfunc, pub nb_bool: inquiry, pub nb_invert: unaryfunc, pub nb_lshift: binaryfunc, pub nb_rshift: binaryfunc, pub nb_and: binaryfunc, pub nb_xor: binaryfunc, pub nb_or: binaryfunc, pub nb_int: unaryfunc, pub nb_reserved: *mut ::std::os::raw::c_void, pub nb_float: unaryfunc, pub nb_inplace_add: binaryfunc, pub nb_inplace_subtract: binaryfunc, pub nb_inplace_multiply: binaryfunc, pub nb_inplace_remainder: binaryfunc, pub nb_inplace_power: ternaryfunc, pub nb_inplace_lshift: binaryfunc, pub nb_inplace_rshift: binaryfunc, pub nb_inplace_and: binaryfunc, pub nb_inplace_xor: binaryfunc, pub nb_inplace_or: binaryfunc, pub nb_floor_divide: binaryfunc, pub nb_true_divide: binaryfunc, pub nb_inplace_floor_divide: binaryfunc, pub nb_inplace_true_divide: binaryfunc, pub nb_index: unaryfunc, pub nb_matrix_multiply: binaryfunc, pub nb_inplace_matrix_multiply: binaryfunc, } impl Default for PyNumberMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PySequenceMethods { pub sq_length: lenfunc, pub sq_concat: binaryfunc, pub sq_repeat: ssizeargfunc, pub sq_item: ssizeargfunc, pub was_sq_slice: *mut ::std::os::raw::c_void, pub sq_ass_item: ssizeobjargproc, pub was_sq_ass_slice: *mut ::std::os::raw::c_void, pub sq_contains: objobjproc, pub sq_inplace_concat: binaryfunc, pub sq_inplace_repeat: ssizeargfunc, } impl Default for PySequenceMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyMappingMethods { pub mp_length: lenfunc, pub mp_subscript: binaryfunc, pub mp_ass_subscript: objobjargproc, } impl Default for PyMappingMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyAsyncMethods { pub am_await: unaryfunc, pub am_aiter: unaryfunc, pub am_anext: unaryfunc, } impl Default for PyAsyncMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyBufferProcs { pub bf_getbuffer: getbufferproc, pub bf_releasebuffer: releasebufferproc, } impl Default for PyBufferProcs { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type freefunc = ::std::option::Option; pub type destructor = ::std::option::Option; pub type printfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut FILE, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >; pub type getattrfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_char) -> *mut PyObject, >; pub type getattrofunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject, >; pub type setattrfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_char, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type setattrofunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type reprfunc = ::std::option::Option *mut PyObject>; pub type hashfunc = ::std::option::Option Py_hash_t>; pub type richcmpfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: ::std::os::raw::c_int, ) -> *mut PyObject, >; pub type getiterfunc = ::std::option::Option *mut PyObject>; pub type iternextfunc = ::std::option::Option *mut PyObject>; pub type descrgetfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> *mut PyObject, >; pub type descrsetfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type initproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type newfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut _typeobject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> *mut PyObject, >; pub type allocfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut _typeobject, arg2: Py_ssize_t) -> *mut PyObject, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _typeobject { pub ob_base: PyVarObject, pub tp_name: *const ::std::os::raw::c_char, pub tp_basicsize: Py_ssize_t, pub tp_itemsize: Py_ssize_t, pub tp_dealloc: destructor, pub tp_print: printfunc, pub tp_getattr: getattrfunc, pub tp_setattr: setattrfunc, pub tp_as_async: *mut PyAsyncMethods, pub tp_repr: reprfunc, pub tp_as_number: *mut PyNumberMethods, pub tp_as_sequence: *mut PySequenceMethods, pub tp_as_mapping: *mut PyMappingMethods, pub tp_hash: hashfunc, pub tp_call: ternaryfunc, pub tp_str: reprfunc, pub tp_getattro: getattrofunc, pub tp_setattro: setattrofunc, pub tp_as_buffer: *mut PyBufferProcs, pub tp_flags: ::std::os::raw::c_ulong, pub tp_doc: *const ::std::os::raw::c_char, pub tp_traverse: traverseproc, pub tp_clear: inquiry, pub tp_richcompare: richcmpfunc, pub tp_weaklistoffset: Py_ssize_t, pub tp_iter: getiterfunc, pub tp_iternext: iternextfunc, pub tp_methods: *mut PyMethodDef, pub tp_members: *mut PyMemberDef, pub tp_getset: *mut PyGetSetDef, pub tp_base: *mut _typeobject, pub tp_dict: *mut PyObject, pub tp_descr_get: descrgetfunc, pub tp_descr_set: descrsetfunc, pub tp_dictoffset: Py_ssize_t, pub tp_init: initproc, pub tp_alloc: allocfunc, pub tp_new: newfunc, pub tp_free: freefunc, pub tp_is_gc: inquiry, pub tp_bases: *mut PyObject, pub tp_mro: *mut PyObject, pub tp_cache: *mut PyObject, pub tp_subclasses: *mut PyObject, pub tp_weaklist: *mut PyObject, pub tp_del: destructor, pub tp_version_tag: ::std::os::raw::c_uint, pub tp_finalize: destructor, } impl Default for _typeobject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyTypeObject = _typeobject; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyBytesObject { pub ob_base: PyVarObject, pub ob_shash: Py_hash_t, pub ob_sval: [::std::os::raw::c_char; 1usize], } impl Default for PyBytesObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type Py_UCS4 = u32; pub type Py_UCS2 = u16; pub type Py_UCS1 = u8; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyASCIIObject { pub ob_base: PyObject, pub length: Py_ssize_t, pub hash: Py_hash_t, pub state: PyASCIIObject__bindgen_ty_1, pub wstr: *mut wchar_t, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct PyASCIIObject__bindgen_ty_1 { pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u8>, pub __bindgen_align: [u32; 0usize], } impl PyASCIIObject__bindgen_ty_1 { #[inline] pub fn interned(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) } } #[inline] pub fn set_interned(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(0usize, 2u8, val as u64) } } #[inline] pub fn kind(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 3u8) as u32) } } #[inline] pub fn set_kind(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(2usize, 3u8, val as u64) } } #[inline] pub fn compact(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } } #[inline] pub fn set_compact(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(5usize, 1u8, val as u64) } } #[inline] pub fn ascii(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } } #[inline] pub fn set_ascii(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(6usize, 1u8, val as u64) } } #[inline] pub fn ready(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } } #[inline] pub fn set_ready(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(7usize, 1u8, val as u64) } } #[inline] pub fn new_bitfield_1( interned: ::std::os::raw::c_uint, kind: ::std::os::raw::c_uint, compact: ::std::os::raw::c_uint, ascii: ::std::os::raw::c_uint, ready: ::std::os::raw::c_uint, ) -> __BindgenBitfieldUnit<[u8; 4usize], u8> { let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u8> = Default::default(); __bindgen_bitfield_unit.set(0usize, 2u8, { let interned: u32 = unsafe { ::std::mem::transmute(interned) }; interned as u64 }); __bindgen_bitfield_unit.set(2usize, 3u8, { let kind: u32 = unsafe { ::std::mem::transmute(kind) }; kind as u64 }); __bindgen_bitfield_unit.set(5usize, 1u8, { let compact: u32 = unsafe { ::std::mem::transmute(compact) }; compact as u64 }); __bindgen_bitfield_unit.set(6usize, 1u8, { let ascii: u32 = unsafe { ::std::mem::transmute(ascii) }; ascii as u64 }); __bindgen_bitfield_unit.set(7usize, 1u8, { let ready: u32 = unsafe { ::std::mem::transmute(ready) }; ready as u64 }); __bindgen_bitfield_unit } } impl Default for PyASCIIObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyCompactUnicodeObject { pub _base: PyASCIIObject, pub utf8_length: Py_ssize_t, pub utf8: *mut ::std::os::raw::c_char, pub wstr_length: Py_ssize_t, } impl Default for PyCompactUnicodeObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct PyUnicodeObject { pub _base: PyCompactUnicodeObject, pub data: PyUnicodeObject__bindgen_ty_1, } #[repr(C)] #[derive(Copy, Clone)] pub union PyUnicodeObject__bindgen_ty_1 { pub any: *mut ::std::os::raw::c_void, pub latin1: *mut Py_UCS1, pub ucs2: *mut Py_UCS2, pub ucs4: *mut Py_UCS4, _bindgen_union_align: u64, } impl Default for PyUnicodeObject__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for PyUnicodeObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyLongObject = _longobject; #[cfg(target_pointer_width = "64")] pub type digit = u32; #[cfg(target_pointer_width = "32")] pub type digit = u16; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _longobject { pub ob_base: PyVarObject, pub ob_digit: [digit; 1usize], } impl Default for _longobject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyFloatObject { pub ob_base: PyObject, pub ob_fval: f64, } impl Default for PyFloatObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyTupleObject { pub ob_base: PyVarObject, pub ob_item: [*mut PyObject; 1usize], } impl Default for PyTupleObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyListObject { pub ob_base: PyVarObject, pub ob_item: *mut *mut PyObject, pub allocated: Py_ssize_t, } impl Default for PyListObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyDictKeysObject = _dictkeysobject; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyDictObject { pub ob_base: PyObject, pub ma_used: Py_ssize_t, pub ma_version_tag: u64, pub ma_keys: *mut PyDictKeysObject, pub ma_values: *mut *mut PyObject, } impl Default for PyDictObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyCFunction = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyMethodDef { pub ml_name: *const ::std::os::raw::c_char, pub ml_meth: PyCFunction, pub ml_flags: ::std::os::raw::c_int, pub ml_doc: *const ::std::os::raw::c_char, } impl Default for PyMethodDef { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type _PyFrameEvalFunction = ::std::option::Option< unsafe extern "C" fn(arg1: *mut _frame, arg2: ::std::os::raw::c_int) -> *mut PyObject, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _is { pub next: *mut _is, pub tstate_head: *mut _ts, pub modules: *mut PyObject, pub modules_by_index: *mut PyObject, pub sysdict: *mut PyObject, pub builtins: *mut PyObject, pub importlib: *mut PyObject, pub codec_search_path: *mut PyObject, pub codec_search_cache: *mut PyObject, pub codec_error_registry: *mut PyObject, pub codecs_initialized: ::std::os::raw::c_int, pub fscodec_initialized: ::std::os::raw::c_int, pub dlopenflags: ::std::os::raw::c_int, pub builtins_copy: *mut PyObject, pub import_func: *mut PyObject, pub eval_frame: _PyFrameEvalFunction, } impl Default for _is { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyInterpreterState = _is; pub type Py_tracefunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut _frame, arg3: ::std::os::raw::c_int, arg4: *mut PyObject, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Copy, Clone)] pub struct _ts { pub prev: *mut _ts, pub next: *mut _ts, pub interp: *mut PyInterpreterState, pub frame: *mut _frame, pub recursion_depth: ::std::os::raw::c_int, pub overflowed: ::std::os::raw::c_char, pub recursion_critical: ::std::os::raw::c_char, pub tracing: ::std::os::raw::c_int, pub use_tracing: ::std::os::raw::c_int, pub c_profilefunc: Py_tracefunc, pub c_tracefunc: Py_tracefunc, pub c_profileobj: *mut PyObject, pub c_traceobj: *mut PyObject, pub curexc_type: *mut PyObject, pub curexc_value: *mut PyObject, pub curexc_traceback: *mut PyObject, pub exc_type: *mut PyObject, pub exc_value: *mut PyObject, pub exc_traceback: *mut PyObject, pub dict: *mut PyObject, pub gilstate_counter: ::std::os::raw::c_int, pub async_exc: *mut PyObject, pub thread_id: ::std::os::raw::c_long, pub trash_delete_nesting: ::std::os::raw::c_int, pub trash_delete_later: *mut PyObject, pub on_delete: ::std::option::Option, pub on_delete_data: *mut ::std::os::raw::c_void, pub coroutine_wrapper: *mut PyObject, pub in_coroutine_wrapper: ::std::os::raw::c_int, pub _preserve_36_ABI_1: Py_ssize_t, pub _preserve_36_ABI_2: [freefunc; 255usize], pub async_gen_firstiter: *mut PyObject, pub async_gen_finalizer: *mut PyObject, } impl Default for _ts { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyThreadState = _ts; pub type getter = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_void) -> *mut PyObject, >; pub type setter = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyGetSetDef { pub name: *mut ::std::os::raw::c_char, pub get: getter, pub set: setter, pub doc: *mut ::std::os::raw::c_char, pub closure: *mut ::std::os::raw::c_void, } impl Default for PyGetSetDef { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyMemberDef { _unused: [u8; 0], } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyCodeObject { pub ob_base: PyObject, pub co_argcount: ::std::os::raw::c_int, pub co_kwonlyargcount: ::std::os::raw::c_int, pub co_nlocals: ::std::os::raw::c_int, pub co_stacksize: ::std::os::raw::c_int, pub co_flags: ::std::os::raw::c_int, pub co_firstlineno: ::std::os::raw::c_int, pub co_code: *mut PyObject, pub co_consts: *mut PyObject, pub co_names: *mut PyObject, pub co_varnames: *mut PyObject, pub co_freevars: *mut PyObject, pub co_cellvars: *mut PyObject, pub co_cell2arg: *mut ::std::os::raw::c_uchar, pub co_filename: *mut PyObject, pub co_name: *mut PyObject, pub co_lnotab: *mut PyObject, pub co_zombieframe: *mut ::std::os::raw::c_void, pub co_weakreflist: *mut PyObject, pub co_extra: *mut ::std::os::raw::c_void, } impl Default for PyCodeObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct PyTryBlock { pub b_type: ::std::os::raw::c_int, pub b_handler: ::std::os::raw::c_int, pub b_level: ::std::os::raw::c_int, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _frame { pub ob_base: PyVarObject, pub f_back: *mut _frame, pub f_code: *mut PyCodeObject, pub f_builtins: *mut PyObject, pub f_globals: *mut PyObject, pub f_locals: *mut PyObject, pub f_valuestack: *mut *mut PyObject, pub f_stacktop: *mut *mut PyObject, pub f_trace: *mut PyObject, pub f_exc_type: *mut PyObject, pub f_exc_value: *mut PyObject, pub f_exc_traceback: *mut PyObject, pub f_gen: *mut PyObject, pub f_lasti: ::std::os::raw::c_int, pub f_lineno: ::std::os::raw::c_int, pub f_iblock: ::std::os::raw::c_int, pub f_executing: ::std::os::raw::c_char, pub f_blockstack: [PyTryBlock; 20usize], pub f_localsplus: [*mut PyObject; 1usize], } impl Default for _frame { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyFrameObject = _frame; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyDictKeyEntry { pub me_hash: Py_hash_t, pub me_key: *mut PyObject, pub me_value: *mut PyObject, } impl Default for PyDictKeyEntry { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type dict_lookup_func = ::std::option::Option< unsafe extern "C" fn( mp: *mut PyDictObject, key: *mut PyObject, hash: Py_hash_t, value_addr: *mut *mut *mut PyObject, hashpos: *mut Py_ssize_t, ) -> Py_ssize_t, >; #[repr(C)] #[derive(Copy, Clone)] pub struct _dictkeysobject { pub dk_refcnt: Py_ssize_t, pub dk_size: Py_ssize_t, pub dk_lookup: dict_lookup_func, pub dk_usable: Py_ssize_t, pub dk_nentries: Py_ssize_t, pub dk_indices: _dictkeysobject__bindgen_ty_1, } #[repr(C)] #[derive(Copy, Clone)] pub union _dictkeysobject__bindgen_ty_1 { pub as_1: [i8; 8usize], pub as_2: [i16; 4usize], pub as_4: [i32; 2usize], pub as_8: [i64; 1usize], _bindgen_union_align: u64, } impl Default for _dictkeysobject__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for _dictkeysobject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } ================================================ FILE: src/python_bindings/v3_7_0.rs ================================================ // Generated bindings for python v3.7.0 #![allow(dead_code)] #![allow(non_upper_case_globals)] #![allow(non_camel_case_types)] #![allow(non_snake_case)] #![allow(clippy::useless_transmute)] #![allow(clippy::default_trait_access)] #![allow(clippy::cast_lossless)] #![allow(clippy::trivially_copy_pass_by_ref)] #![allow(clippy::upper_case_acronyms)] /* automatically generated by rust-bindgen */ #[repr(C)] #[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] pub struct __BindgenBitfieldUnit where Storage: AsRef<[u8]> + AsMut<[u8]>, { storage: Storage, align: [Align; 0], } impl __BindgenBitfieldUnit where Storage: AsRef<[u8]> + AsMut<[u8]>, { #[inline] pub fn new(storage: Storage) -> Self { Self { storage, align: [] } } #[inline] pub fn get_bit(&self, index: usize) -> bool { debug_assert!(index / 8 < self.storage.as_ref().len()); let byte_index = index / 8; let byte = self.storage.as_ref()[byte_index]; let bit_index = index % 8; let mask = 1 << bit_index; byte & mask == mask } #[inline] pub fn set_bit(&mut self, index: usize, val: bool) { debug_assert!(index / 8 < self.storage.as_ref().len()); let byte_index = index / 8; let byte = &mut self.storage.as_mut()[byte_index]; let bit_index = index % 8; let mask = 1 << bit_index; if val { *byte |= mask; } else { *byte &= !mask; } } #[inline] pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); let mut val = 0; for i in 0..(bit_width as usize) { if self.get_bit(i + bit_offset) { val |= 1 << i; } } val } #[inline] pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); for i in 0..(bit_width as usize) { let mask = 1 << i; let val_bit_is_set = val & mask == mask; self.set_bit(i + bit_offset, val_bit_is_set); } } } #[repr(C)] #[derive(Default)] pub struct __IncompleteArrayField(::std::marker::PhantomData); impl __IncompleteArrayField { #[inline] pub fn new() -> Self { __IncompleteArrayField(::std::marker::PhantomData) } #[inline] pub unsafe fn as_ptr(&self) -> *const T { ::std::mem::transmute(self) } #[inline] pub unsafe fn as_mut_ptr(&mut self) -> *mut T { ::std::mem::transmute(self) } #[inline] pub unsafe fn as_slice(&self, len: usize) -> &[T] { ::std::slice::from_raw_parts(self.as_ptr(), len) } #[inline] pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] { ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len) } } impl ::std::fmt::Debug for __IncompleteArrayField { fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { fmt.write_str("__IncompleteArrayField") } } impl ::std::clone::Clone for __IncompleteArrayField { #[inline] fn clone(&self) -> Self { *self } } impl ::std::marker::Copy for __IncompleteArrayField {} pub type __int64_t = ::std::os::raw::c_longlong; pub type __darwin_size_t = ::std::os::raw::c_ulong; pub type __darwin_wchar_t = ::std::os::raw::c_int; pub type __darwin_ssize_t = ::std::os::raw::c_long; pub type __darwin_off_t = __int64_t; pub type fpos_t = __darwin_off_t; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct __sbuf { pub _base: *mut ::std::os::raw::c_uchar, pub _size: ::std::os::raw::c_int, } impl Default for __sbuf { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct __sFILEX { _unused: [u8; 0], } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct __sFILE { pub _p: *mut ::std::os::raw::c_uchar, pub _r: ::std::os::raw::c_int, pub _w: ::std::os::raw::c_int, pub _flags: ::std::os::raw::c_short, pub _file: ::std::os::raw::c_short, pub _bf: __sbuf, pub _lbfsize: ::std::os::raw::c_int, pub _cookie: *mut ::std::os::raw::c_void, pub _close: ::std::option::Option< unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, >, pub _read: ::std::option::Option< unsafe extern "C" fn( arg1: *mut ::std::os::raw::c_void, arg2: *mut ::std::os::raw::c_char, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >, pub _seek: ::std::option::Option< unsafe extern "C" fn( arg1: *mut ::std::os::raw::c_void, arg2: fpos_t, arg3: ::std::os::raw::c_int, ) -> fpos_t, >, pub _write: ::std::option::Option< unsafe extern "C" fn( arg1: *mut ::std::os::raw::c_void, arg2: *const ::std::os::raw::c_char, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >, pub _ub: __sbuf, pub _extra: *mut __sFILEX, pub _ur: ::std::os::raw::c_int, pub _ubuf: [::std::os::raw::c_uchar; 3usize], pub _nbuf: [::std::os::raw::c_uchar; 1usize], pub _lb: __sbuf, pub _blksize: ::std::os::raw::c_int, pub _offset: fpos_t, } impl Default for __sFILE { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type FILE = __sFILE; pub type wchar_t = __darwin_wchar_t; pub type Py_ssize_t = isize; pub type Py_hash_t = Py_ssize_t; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _object { pub ob_refcnt: Py_ssize_t, pub ob_type: *mut _typeobject, } impl Default for _object { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyObject = _object; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyVarObject { pub ob_base: PyObject, pub ob_size: Py_ssize_t, } impl Default for PyVarObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type unaryfunc = ::std::option::Option *mut PyObject>; pub type binaryfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject, >; pub type ternaryfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> *mut PyObject, >; pub type inquiry = ::std::option::Option ::std::os::raw::c_int>; pub type lenfunc = ::std::option::Option Py_ssize_t>; pub type ssizeargfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: Py_ssize_t) -> *mut PyObject, >; pub type ssizeobjargproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: Py_ssize_t, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type objobjargproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct bufferinfo { pub buf: *mut ::std::os::raw::c_void, pub obj: *mut PyObject, pub len: Py_ssize_t, pub itemsize: Py_ssize_t, pub readonly: ::std::os::raw::c_int, pub ndim: ::std::os::raw::c_int, pub format: *mut ::std::os::raw::c_char, pub shape: *mut Py_ssize_t, pub strides: *mut Py_ssize_t, pub suboffsets: *mut Py_ssize_t, pub internal: *mut ::std::os::raw::c_void, } impl Default for bufferinfo { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type Py_buffer = bufferinfo; pub type getbufferproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut Py_buffer, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >; pub type releasebufferproc = ::std::option::Option; pub type objobjproc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> ::std::os::raw::c_int, >; pub type visitproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; pub type traverseproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: visitproc, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyNumberMethods { pub nb_add: binaryfunc, pub nb_subtract: binaryfunc, pub nb_multiply: binaryfunc, pub nb_remainder: binaryfunc, pub nb_divmod: binaryfunc, pub nb_power: ternaryfunc, pub nb_negative: unaryfunc, pub nb_positive: unaryfunc, pub nb_absolute: unaryfunc, pub nb_bool: inquiry, pub nb_invert: unaryfunc, pub nb_lshift: binaryfunc, pub nb_rshift: binaryfunc, pub nb_and: binaryfunc, pub nb_xor: binaryfunc, pub nb_or: binaryfunc, pub nb_int: unaryfunc, pub nb_reserved: *mut ::std::os::raw::c_void, pub nb_float: unaryfunc, pub nb_inplace_add: binaryfunc, pub nb_inplace_subtract: binaryfunc, pub nb_inplace_multiply: binaryfunc, pub nb_inplace_remainder: binaryfunc, pub nb_inplace_power: ternaryfunc, pub nb_inplace_lshift: binaryfunc, pub nb_inplace_rshift: binaryfunc, pub nb_inplace_and: binaryfunc, pub nb_inplace_xor: binaryfunc, pub nb_inplace_or: binaryfunc, pub nb_floor_divide: binaryfunc, pub nb_true_divide: binaryfunc, pub nb_inplace_floor_divide: binaryfunc, pub nb_inplace_true_divide: binaryfunc, pub nb_index: unaryfunc, pub nb_matrix_multiply: binaryfunc, pub nb_inplace_matrix_multiply: binaryfunc, } impl Default for PyNumberMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PySequenceMethods { pub sq_length: lenfunc, pub sq_concat: binaryfunc, pub sq_repeat: ssizeargfunc, pub sq_item: ssizeargfunc, pub was_sq_slice: *mut ::std::os::raw::c_void, pub sq_ass_item: ssizeobjargproc, pub was_sq_ass_slice: *mut ::std::os::raw::c_void, pub sq_contains: objobjproc, pub sq_inplace_concat: binaryfunc, pub sq_inplace_repeat: ssizeargfunc, } impl Default for PySequenceMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyMappingMethods { pub mp_length: lenfunc, pub mp_subscript: binaryfunc, pub mp_ass_subscript: objobjargproc, } impl Default for PyMappingMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyAsyncMethods { pub am_await: unaryfunc, pub am_aiter: unaryfunc, pub am_anext: unaryfunc, } impl Default for PyAsyncMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyBufferProcs { pub bf_getbuffer: getbufferproc, pub bf_releasebuffer: releasebufferproc, } impl Default for PyBufferProcs { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type freefunc = ::std::option::Option; pub type destructor = ::std::option::Option; pub type printfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut FILE, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >; pub type getattrfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_char) -> *mut PyObject, >; pub type getattrofunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject, >; pub type setattrfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_char, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type setattrofunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type reprfunc = ::std::option::Option *mut PyObject>; pub type hashfunc = ::std::option::Option Py_hash_t>; pub type richcmpfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: ::std::os::raw::c_int, ) -> *mut PyObject, >; pub type getiterfunc = ::std::option::Option *mut PyObject>; pub type iternextfunc = ::std::option::Option *mut PyObject>; pub type descrgetfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> *mut PyObject, >; pub type descrsetfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type initproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type newfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut _typeobject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> *mut PyObject, >; pub type allocfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut _typeobject, arg2: Py_ssize_t) -> *mut PyObject, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _typeobject { pub ob_base: PyVarObject, pub tp_name: *const ::std::os::raw::c_char, pub tp_basicsize: Py_ssize_t, pub tp_itemsize: Py_ssize_t, pub tp_dealloc: destructor, pub tp_print: printfunc, pub tp_getattr: getattrfunc, pub tp_setattr: setattrfunc, pub tp_as_async: *mut PyAsyncMethods, pub tp_repr: reprfunc, pub tp_as_number: *mut PyNumberMethods, pub tp_as_sequence: *mut PySequenceMethods, pub tp_as_mapping: *mut PyMappingMethods, pub tp_hash: hashfunc, pub tp_call: ternaryfunc, pub tp_str: reprfunc, pub tp_getattro: getattrofunc, pub tp_setattro: setattrofunc, pub tp_as_buffer: *mut PyBufferProcs, pub tp_flags: ::std::os::raw::c_ulong, pub tp_doc: *const ::std::os::raw::c_char, pub tp_traverse: traverseproc, pub tp_clear: inquiry, pub tp_richcompare: richcmpfunc, pub tp_weaklistoffset: Py_ssize_t, pub tp_iter: getiterfunc, pub tp_iternext: iternextfunc, pub tp_methods: *mut PyMethodDef, pub tp_members: *mut PyMemberDef, pub tp_getset: *mut PyGetSetDef, pub tp_base: *mut _typeobject, pub tp_dict: *mut PyObject, pub tp_descr_get: descrgetfunc, pub tp_descr_set: descrsetfunc, pub tp_dictoffset: Py_ssize_t, pub tp_init: initproc, pub tp_alloc: allocfunc, pub tp_new: newfunc, pub tp_free: freefunc, pub tp_is_gc: inquiry, pub tp_bases: *mut PyObject, pub tp_mro: *mut PyObject, pub tp_cache: *mut PyObject, pub tp_subclasses: *mut PyObject, pub tp_weaklist: *mut PyObject, pub tp_del: destructor, pub tp_version_tag: ::std::os::raw::c_uint, pub tp_finalize: destructor, } impl Default for _typeobject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyTypeObject = _typeobject; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyBytesObject { pub ob_base: PyVarObject, pub ob_shash: Py_hash_t, pub ob_sval: [::std::os::raw::c_char; 1usize], } impl Default for PyBytesObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type Py_UCS4 = u32; pub type Py_UCS2 = u16; pub type Py_UCS1 = u8; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyASCIIObject { pub ob_base: PyObject, pub length: Py_ssize_t, pub hash: Py_hash_t, pub state: PyASCIIObject__bindgen_ty_1, pub wstr: *mut wchar_t, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct PyASCIIObject__bindgen_ty_1 { pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u8>, pub __bindgen_align: [u32; 0usize], } impl PyASCIIObject__bindgen_ty_1 { #[inline] pub fn interned(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) } } #[inline] pub fn set_interned(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(0usize, 2u8, val as u64) } } #[inline] pub fn kind(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 3u8) as u32) } } #[inline] pub fn set_kind(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(2usize, 3u8, val as u64) } } #[inline] pub fn compact(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } } #[inline] pub fn set_compact(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(5usize, 1u8, val as u64) } } #[inline] pub fn ascii(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } } #[inline] pub fn set_ascii(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(6usize, 1u8, val as u64) } } #[inline] pub fn ready(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } } #[inline] pub fn set_ready(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(7usize, 1u8, val as u64) } } #[inline] pub fn new_bitfield_1( interned: ::std::os::raw::c_uint, kind: ::std::os::raw::c_uint, compact: ::std::os::raw::c_uint, ascii: ::std::os::raw::c_uint, ready: ::std::os::raw::c_uint, ) -> __BindgenBitfieldUnit<[u8; 4usize], u8> { let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u8> = Default::default(); __bindgen_bitfield_unit.set(0usize, 2u8, { let interned: u32 = unsafe { ::std::mem::transmute(interned) }; interned as u64 }); __bindgen_bitfield_unit.set(2usize, 3u8, { let kind: u32 = unsafe { ::std::mem::transmute(kind) }; kind as u64 }); __bindgen_bitfield_unit.set(5usize, 1u8, { let compact: u32 = unsafe { ::std::mem::transmute(compact) }; compact as u64 }); __bindgen_bitfield_unit.set(6usize, 1u8, { let ascii: u32 = unsafe { ::std::mem::transmute(ascii) }; ascii as u64 }); __bindgen_bitfield_unit.set(7usize, 1u8, { let ready: u32 = unsafe { ::std::mem::transmute(ready) }; ready as u64 }); __bindgen_bitfield_unit } } impl Default for PyASCIIObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyCompactUnicodeObject { pub _base: PyASCIIObject, pub utf8_length: Py_ssize_t, pub utf8: *mut ::std::os::raw::c_char, pub wstr_length: Py_ssize_t, } impl Default for PyCompactUnicodeObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct PyUnicodeObject { pub _base: PyCompactUnicodeObject, pub data: PyUnicodeObject__bindgen_ty_1, } #[repr(C)] #[derive(Copy, Clone)] pub union PyUnicodeObject__bindgen_ty_1 { pub any: *mut ::std::os::raw::c_void, pub latin1: *mut Py_UCS1, pub ucs2: *mut Py_UCS2, pub ucs4: *mut Py_UCS4, _bindgen_union_align: u64, } impl Default for PyUnicodeObject__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for PyUnicodeObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyLongObject = _longobject; #[cfg(target_pointer_width = "64")] pub type digit = u32; #[cfg(target_pointer_width = "32")] pub type digit = u16; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _longobject { pub ob_base: PyVarObject, pub ob_digit: [digit; 1usize], } impl Default for _longobject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyFloatObject { pub ob_base: PyObject, pub ob_fval: f64, } impl Default for PyFloatObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyTupleObject { pub ob_base: PyVarObject, pub ob_item: [*mut PyObject; 1usize], } impl Default for PyTupleObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyListObject { pub ob_base: PyVarObject, pub ob_item: *mut *mut PyObject, pub allocated: Py_ssize_t, } impl Default for PyListObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyDictKeysObject = _dictkeysobject; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyDictObject { pub ob_base: PyObject, pub ma_used: Py_ssize_t, pub ma_version_tag: u64, pub ma_keys: *mut PyDictKeysObject, pub ma_values: *mut *mut PyObject, } impl Default for PyDictObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyCFunction = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyMethodDef { pub ml_name: *const ::std::os::raw::c_char, pub ml_meth: PyCFunction, pub ml_flags: ::std::os::raw::c_int, pub ml_doc: *const ::std::os::raw::c_char, } impl Default for PyMethodDef { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyThread_type_lock = *mut ::std::os::raw::c_void; pub type _PyFrameEvalFunction = ::std::option::Option< unsafe extern "C" fn(arg1: *mut _frame, arg2: ::std::os::raw::c_int) -> *mut PyObject, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _PyCoreConfig { pub install_signal_handlers: ::std::os::raw::c_int, pub ignore_environment: ::std::os::raw::c_int, pub use_hash_seed: ::std::os::raw::c_int, pub hash_seed: ::std::os::raw::c_ulong, pub allocator: *const ::std::os::raw::c_char, pub dev_mode: ::std::os::raw::c_int, pub faulthandler: ::std::os::raw::c_int, pub tracemalloc: ::std::os::raw::c_int, pub import_time: ::std::os::raw::c_int, pub show_ref_count: ::std::os::raw::c_int, pub show_alloc_count: ::std::os::raw::c_int, pub dump_refs: ::std::os::raw::c_int, pub malloc_stats: ::std::os::raw::c_int, pub coerce_c_locale: ::std::os::raw::c_int, pub coerce_c_locale_warn: ::std::os::raw::c_int, pub utf8_mode: ::std::os::raw::c_int, pub program_name: *mut wchar_t, pub argc: ::std::os::raw::c_int, pub argv: *mut *mut wchar_t, pub program: *mut wchar_t, pub nxoption: ::std::os::raw::c_int, pub xoptions: *mut *mut wchar_t, pub nwarnoption: ::std::os::raw::c_int, pub warnoptions: *mut *mut wchar_t, pub module_search_path_env: *mut wchar_t, pub home: *mut wchar_t, pub nmodule_search_path: ::std::os::raw::c_int, pub module_search_paths: *mut *mut wchar_t, pub executable: *mut wchar_t, pub prefix: *mut wchar_t, pub base_prefix: *mut wchar_t, pub exec_prefix: *mut wchar_t, pub base_exec_prefix: *mut wchar_t, pub _disable_importlib: ::std::os::raw::c_int, } impl Default for _PyCoreConfig { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _PyMainInterpreterConfig { pub install_signal_handlers: ::std::os::raw::c_int, pub argv: *mut PyObject, pub executable: *mut PyObject, pub prefix: *mut PyObject, pub base_prefix: *mut PyObject, pub exec_prefix: *mut PyObject, pub base_exec_prefix: *mut PyObject, pub warnoptions: *mut PyObject, pub xoptions: *mut PyObject, pub module_search_path: *mut PyObject, } impl Default for _PyMainInterpreterConfig { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _is { pub next: *mut _is, pub tstate_head: *mut _ts, pub id: i64, pub id_refcount: i64, pub id_mutex: PyThread_type_lock, pub modules: *mut PyObject, pub modules_by_index: *mut PyObject, pub sysdict: *mut PyObject, pub builtins: *mut PyObject, pub importlib: *mut PyObject, pub check_interval: ::std::os::raw::c_int, pub num_threads: ::std::os::raw::c_long, pub pythread_stacksize: usize, pub codec_search_path: *mut PyObject, pub codec_search_cache: *mut PyObject, pub codec_error_registry: *mut PyObject, pub codecs_initialized: ::std::os::raw::c_int, pub fscodec_initialized: ::std::os::raw::c_int, pub core_config: _PyCoreConfig, pub config: _PyMainInterpreterConfig, pub dlopenflags: ::std::os::raw::c_int, pub builtins_copy: *mut PyObject, pub import_func: *mut PyObject, pub eval_frame: _PyFrameEvalFunction, pub co_extra_user_count: Py_ssize_t, pub co_extra_freefuncs: [freefunc; 255usize], pub before_forkers: *mut PyObject, pub after_forkers_parent: *mut PyObject, pub after_forkers_child: *mut PyObject, pub pyexitfunc: ::std::option::Option, pub pyexitmodule: *mut PyObject, pub tstate_next_unique_id: u64, } impl Default for _is { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyInterpreterState = _is; pub type Py_tracefunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut _frame, arg3: ::std::os::raw::c_int, arg4: *mut PyObject, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _err_stackitem { pub exc_type: *mut PyObject, pub exc_value: *mut PyObject, pub exc_traceback: *mut PyObject, pub previous_item: *mut _err_stackitem, } impl Default for _err_stackitem { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type _PyErr_StackItem = _err_stackitem; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _ts { pub prev: *mut _ts, pub next: *mut _ts, pub interp: *mut PyInterpreterState, pub frame: *mut _frame, pub recursion_depth: ::std::os::raw::c_int, pub overflowed: ::std::os::raw::c_char, pub recursion_critical: ::std::os::raw::c_char, pub stackcheck_counter: ::std::os::raw::c_int, pub tracing: ::std::os::raw::c_int, pub use_tracing: ::std::os::raw::c_int, pub c_profilefunc: Py_tracefunc, pub c_tracefunc: Py_tracefunc, pub c_profileobj: *mut PyObject, pub c_traceobj: *mut PyObject, pub curexc_type: *mut PyObject, pub curexc_value: *mut PyObject, pub curexc_traceback: *mut PyObject, pub exc_state: _PyErr_StackItem, pub exc_info: *mut _PyErr_StackItem, pub dict: *mut PyObject, pub gilstate_counter: ::std::os::raw::c_int, pub async_exc: *mut PyObject, pub thread_id: ::std::os::raw::c_ulong, pub trash_delete_nesting: ::std::os::raw::c_int, pub trash_delete_later: *mut PyObject, pub on_delete: ::std::option::Option, pub on_delete_data: *mut ::std::os::raw::c_void, pub coroutine_origin_tracking_depth: ::std::os::raw::c_int, pub coroutine_wrapper: *mut PyObject, pub in_coroutine_wrapper: ::std::os::raw::c_int, pub async_gen_firstiter: *mut PyObject, pub async_gen_finalizer: *mut PyObject, pub context: *mut PyObject, pub context_ver: u64, pub id: u64, } impl Default for _ts { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyThreadState = _ts; pub type getter = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_void) -> *mut PyObject, >; pub type setter = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyGetSetDef { pub name: *const ::std::os::raw::c_char, pub get: getter, pub set: setter, pub doc: *const ::std::os::raw::c_char, pub closure: *mut ::std::os::raw::c_void, } impl Default for PyGetSetDef { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyMemberDef { _unused: [u8; 0], } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyCodeObject { pub ob_base: PyObject, pub co_argcount: ::std::os::raw::c_int, pub co_kwonlyargcount: ::std::os::raw::c_int, pub co_nlocals: ::std::os::raw::c_int, pub co_stacksize: ::std::os::raw::c_int, pub co_flags: ::std::os::raw::c_int, pub co_firstlineno: ::std::os::raw::c_int, pub co_code: *mut PyObject, pub co_consts: *mut PyObject, pub co_names: *mut PyObject, pub co_varnames: *mut PyObject, pub co_freevars: *mut PyObject, pub co_cellvars: *mut PyObject, pub co_cell2arg: *mut Py_ssize_t, pub co_filename: *mut PyObject, pub co_name: *mut PyObject, pub co_lnotab: *mut PyObject, pub co_zombieframe: *mut ::std::os::raw::c_void, pub co_weakreflist: *mut PyObject, pub co_extra: *mut ::std::os::raw::c_void, } impl Default for PyCodeObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct PyTryBlock { pub b_type: ::std::os::raw::c_int, pub b_handler: ::std::os::raw::c_int, pub b_level: ::std::os::raw::c_int, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _frame { pub ob_base: PyVarObject, pub f_back: *mut _frame, pub f_code: *mut PyCodeObject, pub f_builtins: *mut PyObject, pub f_globals: *mut PyObject, pub f_locals: *mut PyObject, pub f_valuestack: *mut *mut PyObject, pub f_stacktop: *mut *mut PyObject, pub f_trace: *mut PyObject, pub f_trace_lines: ::std::os::raw::c_char, pub f_trace_opcodes: ::std::os::raw::c_char, pub f_gen: *mut PyObject, pub f_lasti: ::std::os::raw::c_int, pub f_lineno: ::std::os::raw::c_int, pub f_iblock: ::std::os::raw::c_int, pub f_executing: ::std::os::raw::c_char, pub f_blockstack: [PyTryBlock; 20usize], pub f_localsplus: [*mut PyObject; 1usize], } impl Default for _frame { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyFrameObject = _frame; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyDictKeyEntry { pub me_hash: Py_hash_t, pub me_key: *mut PyObject, pub me_value: *mut PyObject, } impl Default for PyDictKeyEntry { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type dict_lookup_func = ::std::option::Option< unsafe extern "C" fn( mp: *mut PyDictObject, key: *mut PyObject, hash: Py_hash_t, value_addr: *mut *mut PyObject, ) -> Py_ssize_t, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _dictkeysobject { pub dk_refcnt: Py_ssize_t, pub dk_size: Py_ssize_t, pub dk_lookup: dict_lookup_func, pub dk_usable: Py_ssize_t, pub dk_nentries: Py_ssize_t, pub dk_indices: __IncompleteArrayField<::std::os::raw::c_char>, } impl Default for _dictkeysobject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } ================================================ FILE: src/python_bindings/v3_8_0.rs ================================================ // Generated bindings for python v3.8.0b4 #![allow(dead_code)] #![allow(non_upper_case_globals)] #![allow(non_camel_case_types)] #![allow(non_snake_case)] #![allow(clippy::useless_transmute)] #![allow(clippy::default_trait_access)] #![allow(clippy::cast_lossless)] #![allow(clippy::trivially_copy_pass_by_ref)] #![allow(clippy::upper_case_acronyms)] /* automatically generated by rust-bindgen */ #[repr(C)] #[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] pub struct __BindgenBitfieldUnit where Storage: AsRef<[u8]> + AsMut<[u8]>, { storage: Storage, align: [Align; 0], } impl __BindgenBitfieldUnit where Storage: AsRef<[u8]> + AsMut<[u8]>, { #[inline] pub fn new(storage: Storage) -> Self { Self { storage, align: [] } } #[inline] pub fn get_bit(&self, index: usize) -> bool { debug_assert!(index / 8 < self.storage.as_ref().len()); let byte_index = index / 8; let byte = self.storage.as_ref()[byte_index]; let bit_index = index % 8; let mask = 1 << bit_index; byte & mask == mask } #[inline] pub fn set_bit(&mut self, index: usize, val: bool) { debug_assert!(index / 8 < self.storage.as_ref().len()); let byte_index = index / 8; let byte = &mut self.storage.as_mut()[byte_index]; let bit_index = index % 8; let mask = 1 << bit_index; if val { *byte |= mask; } else { *byte &= !mask; } } #[inline] pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); let mut val = 0; for i in 0..(bit_width as usize) { if self.get_bit(i + bit_offset) { val |= 1 << i; } } val } #[inline] pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); for i in 0..(bit_width as usize) { let mask = 1 << i; let val_bit_is_set = val & mask == mask; self.set_bit(i + bit_offset, val_bit_is_set); } } } #[repr(C)] #[derive(Default)] pub struct __IncompleteArrayField(::std::marker::PhantomData); impl __IncompleteArrayField { #[inline] pub fn new() -> Self { __IncompleteArrayField(::std::marker::PhantomData) } #[inline] pub unsafe fn as_ptr(&self) -> *const T { ::std::mem::transmute(self) } #[inline] pub unsafe fn as_mut_ptr(&mut self) -> *mut T { ::std::mem::transmute(self) } #[inline] pub unsafe fn as_slice(&self, len: usize) -> &[T] { ::std::slice::from_raw_parts(self.as_ptr(), len) } #[inline] pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] { ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len) } } impl ::std::fmt::Debug for __IncompleteArrayField { fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { fmt.write_str("__IncompleteArrayField") } } impl ::std::clone::Clone for __IncompleteArrayField { #[inline] fn clone(&self) -> Self { *self } } impl ::std::marker::Copy for __IncompleteArrayField {} pub type __int64_t = ::std::os::raw::c_longlong; pub type __darwin_size_t = ::std::os::raw::c_ulong; pub type __darwin_wchar_t = ::std::os::raw::c_int; pub type __darwin_ssize_t = ::std::os::raw::c_long; pub type __darwin_off_t = __int64_t; pub type fpos_t = __darwin_off_t; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct __sbuf { pub _base: *mut ::std::os::raw::c_uchar, pub _size: ::std::os::raw::c_int, } impl Default for __sbuf { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct __sFILEX { _unused: [u8; 0], } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct __sFILE { pub _p: *mut ::std::os::raw::c_uchar, pub _r: ::std::os::raw::c_int, pub _w: ::std::os::raw::c_int, pub _flags: ::std::os::raw::c_short, pub _file: ::std::os::raw::c_short, pub _bf: __sbuf, pub _lbfsize: ::std::os::raw::c_int, pub _cookie: *mut ::std::os::raw::c_void, pub _close: ::std::option::Option< unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, >, pub _read: ::std::option::Option< unsafe extern "C" fn( arg1: *mut ::std::os::raw::c_void, arg2: *mut ::std::os::raw::c_char, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >, pub _seek: ::std::option::Option< unsafe extern "C" fn( arg1: *mut ::std::os::raw::c_void, arg2: fpos_t, arg3: ::std::os::raw::c_int, ) -> fpos_t, >, pub _write: ::std::option::Option< unsafe extern "C" fn( arg1: *mut ::std::os::raw::c_void, arg2: *const ::std::os::raw::c_char, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >, pub _ub: __sbuf, pub _extra: *mut __sFILEX, pub _ur: ::std::os::raw::c_int, pub _ubuf: [::std::os::raw::c_uchar; 3usize], pub _nbuf: [::std::os::raw::c_uchar; 1usize], pub _lb: __sbuf, pub _blksize: ::std::os::raw::c_int, pub _offset: fpos_t, } impl Default for __sFILE { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type FILE = __sFILE; pub type wchar_t = __darwin_wchar_t; pub type Py_ssize_t = isize; pub type Py_hash_t = Py_ssize_t; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _object { pub ob_refcnt: Py_ssize_t, pub ob_type: *mut _typeobject, } impl Default for _object { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyObject = _object; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyVarObject { pub ob_base: PyObject, pub ob_size: Py_ssize_t, } impl Default for PyVarObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type unaryfunc = ::std::option::Option *mut PyObject>; pub type binaryfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject, >; pub type ternaryfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> *mut PyObject, >; pub type inquiry = ::std::option::Option ::std::os::raw::c_int>; pub type lenfunc = ::std::option::Option Py_ssize_t>; pub type ssizeargfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: Py_ssize_t) -> *mut PyObject, >; pub type ssizeobjargproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: Py_ssize_t, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type objobjargproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type objobjproc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> ::std::os::raw::c_int, >; pub type visitproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; pub type traverseproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: visitproc, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; pub type freefunc = ::std::option::Option; pub type destructor = ::std::option::Option; pub type getattrfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_char) -> *mut PyObject, >; pub type getattrofunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject, >; pub type setattrfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_char, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type setattrofunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type reprfunc = ::std::option::Option *mut PyObject>; pub type hashfunc = ::std::option::Option Py_hash_t>; pub type richcmpfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: ::std::os::raw::c_int, ) -> *mut PyObject, >; pub type getiterfunc = ::std::option::Option *mut PyObject>; pub type iternextfunc = ::std::option::Option *mut PyObject>; pub type descrgetfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> *mut PyObject, >; pub type descrsetfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type initproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type newfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut _typeobject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> *mut PyObject, >; pub type allocfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut _typeobject, arg2: Py_ssize_t) -> *mut PyObject, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _typeobject { pub ob_base: PyVarObject, pub tp_name: *const ::std::os::raw::c_char, pub tp_basicsize: Py_ssize_t, pub tp_itemsize: Py_ssize_t, pub tp_dealloc: destructor, pub tp_vectorcall_offset: Py_ssize_t, pub tp_getattr: getattrfunc, pub tp_setattr: setattrfunc, pub tp_as_async: *mut PyAsyncMethods, pub tp_repr: reprfunc, pub tp_as_number: *mut PyNumberMethods, pub tp_as_sequence: *mut PySequenceMethods, pub tp_as_mapping: *mut PyMappingMethods, pub tp_hash: hashfunc, pub tp_call: ternaryfunc, pub tp_str: reprfunc, pub tp_getattro: getattrofunc, pub tp_setattro: setattrofunc, pub tp_as_buffer: *mut PyBufferProcs, pub tp_flags: ::std::os::raw::c_ulong, pub tp_doc: *const ::std::os::raw::c_char, pub tp_traverse: traverseproc, pub tp_clear: inquiry, pub tp_richcompare: richcmpfunc, pub tp_weaklistoffset: Py_ssize_t, pub tp_iter: getiterfunc, pub tp_iternext: iternextfunc, pub tp_methods: *mut PyMethodDef, pub tp_members: *mut PyMemberDef, pub tp_getset: *mut PyGetSetDef, pub tp_base: *mut _typeobject, pub tp_dict: *mut PyObject, pub tp_descr_get: descrgetfunc, pub tp_descr_set: descrsetfunc, pub tp_dictoffset: Py_ssize_t, pub tp_init: initproc, pub tp_alloc: allocfunc, pub tp_new: newfunc, pub tp_free: freefunc, pub tp_is_gc: inquiry, pub tp_bases: *mut PyObject, pub tp_mro: *mut PyObject, pub tp_cache: *mut PyObject, pub tp_subclasses: *mut PyObject, pub tp_weaklist: *mut PyObject, pub tp_del: destructor, pub tp_version_tag: ::std::os::raw::c_uint, pub tp_finalize: destructor, pub tp_vectorcall: vectorcallfunc, pub tp_print: ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut FILE, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >, } impl Default for _typeobject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct bufferinfo { pub buf: *mut ::std::os::raw::c_void, pub obj: *mut PyObject, pub len: Py_ssize_t, pub itemsize: Py_ssize_t, pub readonly: ::std::os::raw::c_int, pub ndim: ::std::os::raw::c_int, pub format: *mut ::std::os::raw::c_char, pub shape: *mut Py_ssize_t, pub strides: *mut Py_ssize_t, pub suboffsets: *mut Py_ssize_t, pub internal: *mut ::std::os::raw::c_void, } impl Default for bufferinfo { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type Py_buffer = bufferinfo; pub type getbufferproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut Py_buffer, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >; pub type releasebufferproc = ::std::option::Option; pub type vectorcallfunc = ::std::option::Option< unsafe extern "C" fn( callable: *mut PyObject, args: *const *mut PyObject, nargsf: usize, kwnames: *mut PyObject, ) -> *mut PyObject, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyNumberMethods { pub nb_add: binaryfunc, pub nb_subtract: binaryfunc, pub nb_multiply: binaryfunc, pub nb_remainder: binaryfunc, pub nb_divmod: binaryfunc, pub nb_power: ternaryfunc, pub nb_negative: unaryfunc, pub nb_positive: unaryfunc, pub nb_absolute: unaryfunc, pub nb_bool: inquiry, pub nb_invert: unaryfunc, pub nb_lshift: binaryfunc, pub nb_rshift: binaryfunc, pub nb_and: binaryfunc, pub nb_xor: binaryfunc, pub nb_or: binaryfunc, pub nb_int: unaryfunc, pub nb_reserved: *mut ::std::os::raw::c_void, pub nb_float: unaryfunc, pub nb_inplace_add: binaryfunc, pub nb_inplace_subtract: binaryfunc, pub nb_inplace_multiply: binaryfunc, pub nb_inplace_remainder: binaryfunc, pub nb_inplace_power: ternaryfunc, pub nb_inplace_lshift: binaryfunc, pub nb_inplace_rshift: binaryfunc, pub nb_inplace_and: binaryfunc, pub nb_inplace_xor: binaryfunc, pub nb_inplace_or: binaryfunc, pub nb_floor_divide: binaryfunc, pub nb_true_divide: binaryfunc, pub nb_inplace_floor_divide: binaryfunc, pub nb_inplace_true_divide: binaryfunc, pub nb_index: unaryfunc, pub nb_matrix_multiply: binaryfunc, pub nb_inplace_matrix_multiply: binaryfunc, } impl Default for PyNumberMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PySequenceMethods { pub sq_length: lenfunc, pub sq_concat: binaryfunc, pub sq_repeat: ssizeargfunc, pub sq_item: ssizeargfunc, pub was_sq_slice: *mut ::std::os::raw::c_void, pub sq_ass_item: ssizeobjargproc, pub was_sq_ass_slice: *mut ::std::os::raw::c_void, pub sq_contains: objobjproc, pub sq_inplace_concat: binaryfunc, pub sq_inplace_repeat: ssizeargfunc, } impl Default for PySequenceMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyMappingMethods { pub mp_length: lenfunc, pub mp_subscript: binaryfunc, pub mp_ass_subscript: objobjargproc, } impl Default for PyMappingMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyAsyncMethods { pub am_await: unaryfunc, pub am_aiter: unaryfunc, pub am_anext: unaryfunc, } impl Default for PyAsyncMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyBufferProcs { pub bf_getbuffer: getbufferproc, pub bf_releasebuffer: releasebufferproc, } impl Default for PyBufferProcs { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyTypeObject = _typeobject; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyBytesObject { pub ob_base: PyVarObject, pub ob_shash: Py_hash_t, pub ob_sval: [::std::os::raw::c_char; 1usize], } impl Default for PyBytesObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type Py_UCS4 = u32; pub type Py_UCS2 = u16; pub type Py_UCS1 = u8; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyASCIIObject { pub ob_base: PyObject, pub length: Py_ssize_t, pub hash: Py_hash_t, pub state: PyASCIIObject__bindgen_ty_1, pub wstr: *mut wchar_t, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct PyASCIIObject__bindgen_ty_1 { pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u8>, pub __bindgen_align: [u32; 0usize], } impl PyASCIIObject__bindgen_ty_1 { #[inline] pub fn interned(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) } } #[inline] pub fn set_interned(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(0usize, 2u8, val as u64) } } #[inline] pub fn kind(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 3u8) as u32) } } #[inline] pub fn set_kind(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(2usize, 3u8, val as u64) } } #[inline] pub fn compact(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } } #[inline] pub fn set_compact(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(5usize, 1u8, val as u64) } } #[inline] pub fn ascii(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } } #[inline] pub fn set_ascii(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(6usize, 1u8, val as u64) } } #[inline] pub fn ready(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } } #[inline] pub fn set_ready(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(7usize, 1u8, val as u64) } } #[inline] pub fn new_bitfield_1( interned: ::std::os::raw::c_uint, kind: ::std::os::raw::c_uint, compact: ::std::os::raw::c_uint, ascii: ::std::os::raw::c_uint, ready: ::std::os::raw::c_uint, ) -> __BindgenBitfieldUnit<[u8; 4usize], u8> { let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u8> = Default::default(); __bindgen_bitfield_unit.set(0usize, 2u8, { let interned: u32 = unsafe { ::std::mem::transmute(interned) }; interned as u64 }); __bindgen_bitfield_unit.set(2usize, 3u8, { let kind: u32 = unsafe { ::std::mem::transmute(kind) }; kind as u64 }); __bindgen_bitfield_unit.set(5usize, 1u8, { let compact: u32 = unsafe { ::std::mem::transmute(compact) }; compact as u64 }); __bindgen_bitfield_unit.set(6usize, 1u8, { let ascii: u32 = unsafe { ::std::mem::transmute(ascii) }; ascii as u64 }); __bindgen_bitfield_unit.set(7usize, 1u8, { let ready: u32 = unsafe { ::std::mem::transmute(ready) }; ready as u64 }); __bindgen_bitfield_unit } } impl Default for PyASCIIObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyCompactUnicodeObject { pub _base: PyASCIIObject, pub utf8_length: Py_ssize_t, pub utf8: *mut ::std::os::raw::c_char, pub wstr_length: Py_ssize_t, } impl Default for PyCompactUnicodeObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct PyUnicodeObject { pub _base: PyCompactUnicodeObject, pub data: PyUnicodeObject__bindgen_ty_1, } #[repr(C)] #[derive(Copy, Clone)] pub union PyUnicodeObject__bindgen_ty_1 { pub any: *mut ::std::os::raw::c_void, pub latin1: *mut Py_UCS1, pub ucs2: *mut Py_UCS2, pub ucs4: *mut Py_UCS4, _bindgen_union_align: u64, } impl Default for PyUnicodeObject__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for PyUnicodeObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyLongObject = _longobject; #[cfg(target_pointer_width = "64")] pub type digit = u32; #[cfg(target_pointer_width = "32")] pub type digit = u16; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _longobject { pub ob_base: PyVarObject, pub ob_digit: [digit; 1usize], } impl Default for _longobject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyFloatObject { pub ob_base: PyObject, pub ob_fval: f64, } impl Default for PyFloatObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyTupleObject { pub ob_base: PyVarObject, pub ob_item: [*mut PyObject; 1usize], } impl Default for PyTupleObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyListObject { pub ob_base: PyVarObject, pub ob_item: *mut *mut PyObject, pub allocated: Py_ssize_t, } impl Default for PyListObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyDictKeysObject = _dictkeysobject; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyDictObject { pub ob_base: PyObject, pub ma_used: Py_ssize_t, pub ma_version_tag: u64, pub ma_keys: *mut PyDictKeysObject, pub ma_values: *mut *mut PyObject, } impl Default for PyDictObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyCFunction = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyMethodDef { pub ml_name: *const ::std::os::raw::c_char, pub ml_meth: PyCFunction, pub ml_flags: ::std::os::raw::c_int, pub ml_doc: *const ::std::os::raw::c_char, } impl Default for PyMethodDef { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyThread_type_lock = *mut ::std::os::raw::c_void; pub type PyThreadState = _ts; pub type PyInterpreterState = _is; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyWideStringList { pub length: Py_ssize_t, pub items: *mut *mut wchar_t, } impl Default for PyWideStringList { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyConfig { pub _config_version: ::std::os::raw::c_int, pub _config_init: ::std::os::raw::c_int, pub isolated: ::std::os::raw::c_int, pub use_environment: ::std::os::raw::c_int, pub dev_mode: ::std::os::raw::c_int, pub install_signal_handlers: ::std::os::raw::c_int, pub use_hash_seed: ::std::os::raw::c_int, pub hash_seed: ::std::os::raw::c_ulong, pub faulthandler: ::std::os::raw::c_int, pub tracemalloc: ::std::os::raw::c_int, pub import_time: ::std::os::raw::c_int, pub show_ref_count: ::std::os::raw::c_int, pub show_alloc_count: ::std::os::raw::c_int, pub dump_refs: ::std::os::raw::c_int, pub malloc_stats: ::std::os::raw::c_int, pub filesystem_encoding: *mut wchar_t, pub filesystem_errors: *mut wchar_t, pub pycache_prefix: *mut wchar_t, pub parse_argv: ::std::os::raw::c_int, pub argv: PyWideStringList, pub program_name: *mut wchar_t, pub xoptions: PyWideStringList, pub warnoptions: PyWideStringList, pub site_import: ::std::os::raw::c_int, pub bytes_warning: ::std::os::raw::c_int, pub inspect: ::std::os::raw::c_int, pub interactive: ::std::os::raw::c_int, pub optimization_level: ::std::os::raw::c_int, pub parser_debug: ::std::os::raw::c_int, pub write_bytecode: ::std::os::raw::c_int, pub verbose: ::std::os::raw::c_int, pub quiet: ::std::os::raw::c_int, pub user_site_directory: ::std::os::raw::c_int, pub configure_c_stdio: ::std::os::raw::c_int, pub buffered_stdio: ::std::os::raw::c_int, pub stdio_encoding: *mut wchar_t, pub stdio_errors: *mut wchar_t, pub check_hash_pycs_mode: *mut wchar_t, pub pathconfig_warnings: ::std::os::raw::c_int, pub pythonpath_env: *mut wchar_t, pub home: *mut wchar_t, pub module_search_paths_set: ::std::os::raw::c_int, pub module_search_paths: PyWideStringList, pub executable: *mut wchar_t, pub base_executable: *mut wchar_t, pub prefix: *mut wchar_t, pub base_prefix: *mut wchar_t, pub exec_prefix: *mut wchar_t, pub base_exec_prefix: *mut wchar_t, pub skip_source_first_line: ::std::os::raw::c_int, pub run_command: *mut wchar_t, pub run_module: *mut wchar_t, pub run_filename: *mut wchar_t, pub _install_importlib: ::std::os::raw::c_int, pub _init_main: ::std::os::raw::c_int, } impl Default for PyConfig { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type Py_tracefunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut _frame, arg3: ::std::os::raw::c_int, arg4: *mut PyObject, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _err_stackitem { pub exc_type: *mut PyObject, pub exc_value: *mut PyObject, pub exc_traceback: *mut PyObject, pub previous_item: *mut _err_stackitem, } impl Default for _err_stackitem { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type _PyErr_StackItem = _err_stackitem; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _ts { pub prev: *mut _ts, pub next: *mut _ts, pub interp: *mut PyInterpreterState, pub frame: *mut _frame, pub recursion_depth: ::std::os::raw::c_int, pub overflowed: ::std::os::raw::c_char, pub recursion_critical: ::std::os::raw::c_char, pub stackcheck_counter: ::std::os::raw::c_int, pub tracing: ::std::os::raw::c_int, pub use_tracing: ::std::os::raw::c_int, pub c_profilefunc: Py_tracefunc, pub c_tracefunc: Py_tracefunc, pub c_profileobj: *mut PyObject, pub c_traceobj: *mut PyObject, pub curexc_type: *mut PyObject, pub curexc_value: *mut PyObject, pub curexc_traceback: *mut PyObject, pub exc_state: _PyErr_StackItem, pub exc_info: *mut _PyErr_StackItem, pub dict: *mut PyObject, pub gilstate_counter: ::std::os::raw::c_int, pub async_exc: *mut PyObject, pub thread_id: ::std::os::raw::c_ulong, pub trash_delete_nesting: ::std::os::raw::c_int, pub trash_delete_later: *mut PyObject, pub on_delete: ::std::option::Option, pub on_delete_data: *mut ::std::os::raw::c_void, pub coroutine_origin_tracking_depth: ::std::os::raw::c_int, pub async_gen_firstiter: *mut PyObject, pub async_gen_finalizer: *mut PyObject, pub context: *mut PyObject, pub context_ver: u64, pub id: u64, } impl Default for _ts { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type getter = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_void) -> *mut PyObject, >; pub type setter = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyGetSetDef { pub name: *const ::std::os::raw::c_char, pub get: getter, pub set: setter, pub doc: *const ::std::os::raw::c_char, pub closure: *mut ::std::os::raw::c_void, } impl Default for PyGetSetDef { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyMemberDef { _unused: [u8; 0], } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _PyOpcache { _unused: [u8; 0], } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyCodeObject { pub ob_base: PyObject, pub co_argcount: ::std::os::raw::c_int, pub co_posonlyargcount: ::std::os::raw::c_int, pub co_kwonlyargcount: ::std::os::raw::c_int, pub co_nlocals: ::std::os::raw::c_int, pub co_stacksize: ::std::os::raw::c_int, pub co_flags: ::std::os::raw::c_int, pub co_firstlineno: ::std::os::raw::c_int, pub co_code: *mut PyObject, pub co_consts: *mut PyObject, pub co_names: *mut PyObject, pub co_varnames: *mut PyObject, pub co_freevars: *mut PyObject, pub co_cellvars: *mut PyObject, pub co_cell2arg: *mut Py_ssize_t, pub co_filename: *mut PyObject, pub co_name: *mut PyObject, pub co_lnotab: *mut PyObject, pub co_zombieframe: *mut ::std::os::raw::c_void, pub co_weakreflist: *mut PyObject, pub co_extra: *mut ::std::os::raw::c_void, pub co_opcache_map: *mut ::std::os::raw::c_uchar, pub co_opcache: *mut _PyOpcache, pub co_opcache_flag: ::std::os::raw::c_int, pub co_opcache_size: ::std::os::raw::c_uchar, } impl Default for PyCodeObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub const _Py_error_handler__Py_ERROR_UNKNOWN: _Py_error_handler = 0; pub const _Py_error_handler__Py_ERROR_STRICT: _Py_error_handler = 1; pub const _Py_error_handler__Py_ERROR_SURROGATEESCAPE: _Py_error_handler = 2; pub const _Py_error_handler__Py_ERROR_REPLACE: _Py_error_handler = 3; pub const _Py_error_handler__Py_ERROR_IGNORE: _Py_error_handler = 4; pub const _Py_error_handler__Py_ERROR_BACKSLASHREPLACE: _Py_error_handler = 5; pub const _Py_error_handler__Py_ERROR_SURROGATEPASS: _Py_error_handler = 6; pub const _Py_error_handler__Py_ERROR_XMLCHARREFREPLACE: _Py_error_handler = 7; pub const _Py_error_handler__Py_ERROR_OTHER: _Py_error_handler = 8; pub type _Py_error_handler = u32; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct PyTryBlock { pub b_type: ::std::os::raw::c_int, pub b_handler: ::std::os::raw::c_int, pub b_level: ::std::os::raw::c_int, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _frame { pub ob_base: PyVarObject, pub f_back: *mut _frame, pub f_code: *mut PyCodeObject, pub f_builtins: *mut PyObject, pub f_globals: *mut PyObject, pub f_locals: *mut PyObject, pub f_valuestack: *mut *mut PyObject, pub f_stacktop: *mut *mut PyObject, pub f_trace: *mut PyObject, pub f_trace_lines: ::std::os::raw::c_char, pub f_trace_opcodes: ::std::os::raw::c_char, pub f_gen: *mut PyObject, pub f_lasti: ::std::os::raw::c_int, pub f_lineno: ::std::os::raw::c_int, pub f_iblock: ::std::os::raw::c_int, pub f_executing: ::std::os::raw::c_char, pub f_blockstack: [PyTryBlock; 20usize], pub f_localsplus: [*mut PyObject; 1usize], } impl Default for _frame { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyFrameObject = _frame; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyDictKeyEntry { pub me_hash: Py_hash_t, pub me_key: *mut PyObject, pub me_value: *mut PyObject, } impl Default for PyDictKeyEntry { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type dict_lookup_func = ::std::option::Option< unsafe extern "C" fn( mp: *mut PyDictObject, key: *mut PyObject, hash: Py_hash_t, value_addr: *mut *mut PyObject, ) -> Py_ssize_t, >; #[repr(C)] #[derive(Debug)] pub struct _dictkeysobject { pub dk_refcnt: Py_ssize_t, pub dk_size: Py_ssize_t, pub dk_lookup: dict_lookup_func, pub dk_usable: Py_ssize_t, pub dk_nentries: Py_ssize_t, pub dk_indices: __IncompleteArrayField<::std::os::raw::c_char>, } impl Default for _dictkeysobject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _warnings_runtime_state { pub filters: *mut PyObject, pub once_registry: *mut PyObject, pub default_action: *mut PyObject, pub filters_version: ::std::os::raw::c_long, } impl Default for _warnings_runtime_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type _PyFrameEvalFunction = ::std::option::Option< unsafe extern "C" fn(arg1: *mut _frame, arg2: ::std::os::raw::c_int) -> *mut PyObject, >; #[repr(C)] #[derive(Copy, Clone)] pub struct _is { pub next: *mut _is, pub tstate_head: *mut _ts, pub id: i64, pub id_refcount: i64, pub requires_idref: ::std::os::raw::c_int, pub id_mutex: PyThread_type_lock, pub finalizing: ::std::os::raw::c_int, pub modules: *mut PyObject, pub modules_by_index: *mut PyObject, pub sysdict: *mut PyObject, pub builtins: *mut PyObject, pub importlib: *mut PyObject, pub check_interval: ::std::os::raw::c_int, pub num_threads: ::std::os::raw::c_long, pub pythread_stacksize: usize, pub codec_search_path: *mut PyObject, pub codec_search_cache: *mut PyObject, pub codec_error_registry: *mut PyObject, pub codecs_initialized: ::std::os::raw::c_int, pub fs_codec: _is__bindgen_ty_1, pub config: PyConfig, pub dlopenflags: ::std::os::raw::c_int, pub dict: *mut PyObject, pub builtins_copy: *mut PyObject, pub import_func: *mut PyObject, pub eval_frame: _PyFrameEvalFunction, pub co_extra_user_count: Py_ssize_t, pub co_extra_freefuncs: [freefunc; 255usize], pub before_forkers: *mut PyObject, pub after_forkers_parent: *mut PyObject, pub after_forkers_child: *mut PyObject, pub pyexitfunc: ::std::option::Option, pub pyexitmodule: *mut PyObject, pub tstate_next_unique_id: u64, pub warnings: _warnings_runtime_state, pub audit_hooks: *mut PyObject, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _is__bindgen_ty_1 { pub encoding: *mut ::std::os::raw::c_char, pub errors: *mut ::std::os::raw::c_char, pub error_handler: _Py_error_handler, } impl Default for _is__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for _is { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } ================================================ FILE: src/python_bindings/v3_9_5.rs ================================================ // Generated bindings for python v3.9.5 #![allow(dead_code)] #![allow(non_upper_case_globals)] #![allow(non_camel_case_types)] #![allow(non_snake_case)] #![allow(clippy::useless_transmute)] #![allow(clippy::default_trait_access)] #![allow(clippy::cast_lossless)] #![allow(clippy::trivially_copy_pass_by_ref)] #![allow(clippy::upper_case_acronyms)] /* automatically generated by rust-bindgen */ #[repr(C)] #[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] pub struct __BindgenBitfieldUnit where Storage: AsRef<[u8]> + AsMut<[u8]>, { storage: Storage, align: [Align; 0], } impl __BindgenBitfieldUnit where Storage: AsRef<[u8]> + AsMut<[u8]>, { #[inline] pub fn new(storage: Storage) -> Self { Self { storage, align: [] } } #[inline] pub fn get_bit(&self, index: usize) -> bool { debug_assert!(index / 8 < self.storage.as_ref().len()); let byte_index = index / 8; let byte = self.storage.as_ref()[byte_index]; let bit_index = if cfg!(target_endian = "big") { 7 - (index % 8) } else { index % 8 }; let mask = 1 << bit_index; byte & mask == mask } #[inline] pub fn set_bit(&mut self, index: usize, val: bool) { debug_assert!(index / 8 < self.storage.as_ref().len()); let byte_index = index / 8; let byte = &mut self.storage.as_mut()[byte_index]; let bit_index = if cfg!(target_endian = "big") { 7 - (index % 8) } else { index % 8 }; let mask = 1 << bit_index; if val { *byte |= mask; } else { *byte &= !mask; } } #[inline] pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); let mut val = 0; for i in 0..(bit_width as usize) { if self.get_bit(i + bit_offset) { let index = if cfg!(target_endian = "big") { bit_width as usize - 1 - i } else { i }; val |= 1 << index; } } val } #[inline] pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); for i in 0..(bit_width as usize) { let mask = 1 << i; let val_bit_is_set = val & mask == mask; let index = if cfg!(target_endian = "big") { bit_width as usize - 1 - i } else { i }; self.set_bit(index + bit_offset, val_bit_is_set); } } } #[repr(C)] #[derive(Default)] pub struct __IncompleteArrayField(::std::marker::PhantomData, [T; 0]); impl __IncompleteArrayField { #[inline] pub fn new() -> Self { __IncompleteArrayField(::std::marker::PhantomData, []) } #[inline] pub unsafe fn as_ptr(&self) -> *const T { ::std::mem::transmute(self) } #[inline] pub unsafe fn as_mut_ptr(&mut self) -> *mut T { ::std::mem::transmute(self) } #[inline] pub unsafe fn as_slice(&self, len: usize) -> &[T] { ::std::slice::from_raw_parts(self.as_ptr(), len) } #[inline] pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] { ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len) } } impl ::std::fmt::Debug for __IncompleteArrayField { fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { fmt.write_str("__IncompleteArrayField") } } impl ::std::clone::Clone for __IncompleteArrayField { #[inline] fn clone(&self) -> Self { Self::new() } } pub type __uint8_t = ::std::os::raw::c_uchar; pub type __uint16_t = ::std::os::raw::c_ushort; pub type __uint32_t = ::std::os::raw::c_uint; pub type __int64_t = ::std::os::raw::c_long; pub type __uint64_t = ::std::os::raw::c_ulong; pub type __ssize_t = ::std::os::raw::c_long; pub type wchar_t = ::std::os::raw::c_int; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct __pthread_internal_list { pub __prev: *mut __pthread_internal_list, pub __next: *mut __pthread_internal_list, } impl Default for __pthread_internal_list { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __pthread_list_t = __pthread_internal_list; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct __pthread_mutex_s { pub __lock: ::std::os::raw::c_int, pub __count: ::std::os::raw::c_uint, pub __owner: ::std::os::raw::c_int, pub __nusers: ::std::os::raw::c_uint, pub __kind: ::std::os::raw::c_int, pub __spins: ::std::os::raw::c_short, pub __elision: ::std::os::raw::c_short, pub __list: __pthread_list_t, } impl Default for __pthread_mutex_s { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct __pthread_cond_s { pub __bindgen_anon_1: __pthread_cond_s__bindgen_ty_1, pub __bindgen_anon_2: __pthread_cond_s__bindgen_ty_2, pub __g_refs: [::std::os::raw::c_uint; 2usize], pub __g_size: [::std::os::raw::c_uint; 2usize], pub __g1_orig_size: ::std::os::raw::c_uint, pub __wrefs: ::std::os::raw::c_uint, pub __g_signals: [::std::os::raw::c_uint; 2usize], } #[repr(C)] #[derive(Copy, Clone)] pub union __pthread_cond_s__bindgen_ty_1 { pub __wseq: ::std::os::raw::c_ulonglong, pub __wseq32: __pthread_cond_s__bindgen_ty_1__bindgen_ty_1, _bindgen_union_align: u64, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct __pthread_cond_s__bindgen_ty_1__bindgen_ty_1 { pub __low: ::std::os::raw::c_uint, pub __high: ::std::os::raw::c_uint, } impl Default for __pthread_cond_s__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub union __pthread_cond_s__bindgen_ty_2 { pub __g1_start: ::std::os::raw::c_ulonglong, pub __g1_start32: __pthread_cond_s__bindgen_ty_2__bindgen_ty_1, _bindgen_union_align: u64, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct __pthread_cond_s__bindgen_ty_2__bindgen_ty_1 { pub __low: ::std::os::raw::c_uint, pub __high: ::std::os::raw::c_uint, } impl Default for __pthread_cond_s__bindgen_ty_2 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for __pthread_cond_s { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type pthread_key_t = ::std::os::raw::c_uint; #[repr(C)] #[derive(Copy, Clone)] pub union pthread_mutex_t { pub __data: __pthread_mutex_s, pub __size: [::std::os::raw::c_char; 40usize], pub __align: ::std::os::raw::c_long, _bindgen_union_align: [u64; 5usize], } impl Default for pthread_mutex_t { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub union pthread_cond_t { pub __data: __pthread_cond_s, pub __size: [::std::os::raw::c_char; 48usize], pub __align: ::std::os::raw::c_longlong, _bindgen_union_align: [u64; 6usize], } impl Default for pthread_cond_t { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type Py_ssize_t = isize; pub type Py_hash_t = Py_ssize_t; pub type PyTypeObject = _typeobject; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _object { pub ob_refcnt: Py_ssize_t, pub ob_type: *mut PyTypeObject, } impl Default for _object { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyObject = _object; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyVarObject { pub ob_base: PyObject, pub ob_size: Py_ssize_t, } impl Default for PyVarObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type unaryfunc = ::std::option::Option *mut PyObject>; pub type binaryfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject, >; pub type ternaryfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> *mut PyObject, >; pub type inquiry = ::std::option::Option ::std::os::raw::c_int>; pub type lenfunc = ::std::option::Option Py_ssize_t>; pub type ssizeargfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: Py_ssize_t) -> *mut PyObject, >; pub type ssizeobjargproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: Py_ssize_t, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type objobjargproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type objobjproc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> ::std::os::raw::c_int, >; pub type visitproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; pub type traverseproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: visitproc, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; pub type freefunc = ::std::option::Option; pub type destructor = ::std::option::Option; pub type getattrfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_char) -> *mut PyObject, >; pub type getattrofunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject, >; pub type setattrfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_char, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type setattrofunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type reprfunc = ::std::option::Option *mut PyObject>; pub type hashfunc = ::std::option::Option Py_hash_t>; pub type richcmpfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: ::std::os::raw::c_int, ) -> *mut PyObject, >; pub type getiterfunc = ::std::option::Option *mut PyObject>; pub type iternextfunc = ::std::option::Option *mut PyObject>; pub type descrgetfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> *mut PyObject, >; pub type descrsetfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type initproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> ::std::os::raw::c_int, >; pub type newfunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyTypeObject, arg2: *mut PyObject, arg3: *mut PyObject, ) -> *mut PyObject, >; pub type allocfunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyTypeObject, arg2: Py_ssize_t) -> *mut PyObject, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct bufferinfo { pub buf: *mut ::std::os::raw::c_void, pub obj: *mut PyObject, pub len: Py_ssize_t, pub itemsize: Py_ssize_t, pub readonly: ::std::os::raw::c_int, pub ndim: ::std::os::raw::c_int, pub format: *mut ::std::os::raw::c_char, pub shape: *mut Py_ssize_t, pub strides: *mut Py_ssize_t, pub suboffsets: *mut Py_ssize_t, pub internal: *mut ::std::os::raw::c_void, } impl Default for bufferinfo { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type Py_buffer = bufferinfo; pub type getbufferproc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut Py_buffer, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int, >; pub type releasebufferproc = ::std::option::Option; pub type vectorcallfunc = ::std::option::Option< unsafe extern "C" fn( callable: *mut PyObject, args: *const *mut PyObject, nargsf: usize, kwnames: *mut PyObject, ) -> *mut PyObject, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyNumberMethods { pub nb_add: binaryfunc, pub nb_subtract: binaryfunc, pub nb_multiply: binaryfunc, pub nb_remainder: binaryfunc, pub nb_divmod: binaryfunc, pub nb_power: ternaryfunc, pub nb_negative: unaryfunc, pub nb_positive: unaryfunc, pub nb_absolute: unaryfunc, pub nb_bool: inquiry, pub nb_invert: unaryfunc, pub nb_lshift: binaryfunc, pub nb_rshift: binaryfunc, pub nb_and: binaryfunc, pub nb_xor: binaryfunc, pub nb_or: binaryfunc, pub nb_int: unaryfunc, pub nb_reserved: *mut ::std::os::raw::c_void, pub nb_float: unaryfunc, pub nb_inplace_add: binaryfunc, pub nb_inplace_subtract: binaryfunc, pub nb_inplace_multiply: binaryfunc, pub nb_inplace_remainder: binaryfunc, pub nb_inplace_power: ternaryfunc, pub nb_inplace_lshift: binaryfunc, pub nb_inplace_rshift: binaryfunc, pub nb_inplace_and: binaryfunc, pub nb_inplace_xor: binaryfunc, pub nb_inplace_or: binaryfunc, pub nb_floor_divide: binaryfunc, pub nb_true_divide: binaryfunc, pub nb_inplace_floor_divide: binaryfunc, pub nb_inplace_true_divide: binaryfunc, pub nb_index: unaryfunc, pub nb_matrix_multiply: binaryfunc, pub nb_inplace_matrix_multiply: binaryfunc, } impl Default for PyNumberMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PySequenceMethods { pub sq_length: lenfunc, pub sq_concat: binaryfunc, pub sq_repeat: ssizeargfunc, pub sq_item: ssizeargfunc, pub was_sq_slice: *mut ::std::os::raw::c_void, pub sq_ass_item: ssizeobjargproc, pub was_sq_ass_slice: *mut ::std::os::raw::c_void, pub sq_contains: objobjproc, pub sq_inplace_concat: binaryfunc, pub sq_inplace_repeat: ssizeargfunc, } impl Default for PySequenceMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyMappingMethods { pub mp_length: lenfunc, pub mp_subscript: binaryfunc, pub mp_ass_subscript: objobjargproc, } impl Default for PyMappingMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyAsyncMethods { pub am_await: unaryfunc, pub am_aiter: unaryfunc, pub am_anext: unaryfunc, } impl Default for PyAsyncMethods { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyBufferProcs { pub bf_getbuffer: getbufferproc, pub bf_releasebuffer: releasebufferproc, } impl Default for PyBufferProcs { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _typeobject { pub ob_base: PyVarObject, pub tp_name: *const ::std::os::raw::c_char, pub tp_basicsize: Py_ssize_t, pub tp_itemsize: Py_ssize_t, pub tp_dealloc: destructor, pub tp_vectorcall_offset: Py_ssize_t, pub tp_getattr: getattrfunc, pub tp_setattr: setattrfunc, pub tp_as_async: *mut PyAsyncMethods, pub tp_repr: reprfunc, pub tp_as_number: *mut PyNumberMethods, pub tp_as_sequence: *mut PySequenceMethods, pub tp_as_mapping: *mut PyMappingMethods, pub tp_hash: hashfunc, pub tp_call: ternaryfunc, pub tp_str: reprfunc, pub tp_getattro: getattrofunc, pub tp_setattro: setattrofunc, pub tp_as_buffer: *mut PyBufferProcs, pub tp_flags: ::std::os::raw::c_ulong, pub tp_doc: *const ::std::os::raw::c_char, pub tp_traverse: traverseproc, pub tp_clear: inquiry, pub tp_richcompare: richcmpfunc, pub tp_weaklistoffset: Py_ssize_t, pub tp_iter: getiterfunc, pub tp_iternext: iternextfunc, pub tp_methods: *mut PyMethodDef, pub tp_members: *mut PyMemberDef, pub tp_getset: *mut PyGetSetDef, pub tp_base: *mut _typeobject, pub tp_dict: *mut PyObject, pub tp_descr_get: descrgetfunc, pub tp_descr_set: descrsetfunc, pub tp_dictoffset: Py_ssize_t, pub tp_init: initproc, pub tp_alloc: allocfunc, pub tp_new: newfunc, pub tp_free: freefunc, pub tp_is_gc: inquiry, pub tp_bases: *mut PyObject, pub tp_mro: *mut PyObject, pub tp_cache: *mut PyObject, pub tp_subclasses: *mut PyObject, pub tp_weaklist: *mut PyObject, pub tp_del: destructor, pub tp_version_tag: ::std::os::raw::c_uint, pub tp_finalize: destructor, pub tp_vectorcall: vectorcallfunc, } impl Default for _typeobject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyBytesObject { pub ob_base: PyVarObject, pub ob_shash: Py_hash_t, pub ob_sval: [::std::os::raw::c_char; 1usize], } impl Default for PyBytesObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type Py_UCS4 = u32; pub type Py_UCS2 = u16; pub type Py_UCS1 = u8; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyASCIIObject { pub ob_base: PyObject, pub length: Py_ssize_t, pub hash: Py_hash_t, pub state: PyASCIIObject__bindgen_ty_1, pub wstr: *mut wchar_t, } #[repr(C)] #[repr(align(4))] #[derive(Debug, Default, Copy, Clone)] pub struct PyASCIIObject__bindgen_ty_1 { pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u8>, } impl PyASCIIObject__bindgen_ty_1 { #[inline] pub fn interned(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) } } #[inline] pub fn set_interned(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(0usize, 2u8, val as u64) } } #[inline] pub fn kind(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 3u8) as u32) } } #[inline] pub fn set_kind(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(2usize, 3u8, val as u64) } } #[inline] pub fn compact(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } } #[inline] pub fn set_compact(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(5usize, 1u8, val as u64) } } #[inline] pub fn ascii(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } } #[inline] pub fn set_ascii(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(6usize, 1u8, val as u64) } } #[inline] pub fn ready(&self) -> ::std::os::raw::c_uint { unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } } #[inline] pub fn set_ready(&mut self, val: ::std::os::raw::c_uint) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(7usize, 1u8, val as u64) } } #[inline] pub fn new_bitfield_1( interned: ::std::os::raw::c_uint, kind: ::std::os::raw::c_uint, compact: ::std::os::raw::c_uint, ascii: ::std::os::raw::c_uint, ready: ::std::os::raw::c_uint, ) -> __BindgenBitfieldUnit<[u8; 4usize], u8> { let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u8> = Default::default(); __bindgen_bitfield_unit.set(0usize, 2u8, { let interned: u32 = unsafe { ::std::mem::transmute(interned) }; interned as u64 }); __bindgen_bitfield_unit.set(2usize, 3u8, { let kind: u32 = unsafe { ::std::mem::transmute(kind) }; kind as u64 }); __bindgen_bitfield_unit.set(5usize, 1u8, { let compact: u32 = unsafe { ::std::mem::transmute(compact) }; compact as u64 }); __bindgen_bitfield_unit.set(6usize, 1u8, { let ascii: u32 = unsafe { ::std::mem::transmute(ascii) }; ascii as u64 }); __bindgen_bitfield_unit.set(7usize, 1u8, { let ready: u32 = unsafe { ::std::mem::transmute(ready) }; ready as u64 }); __bindgen_bitfield_unit } } impl Default for PyASCIIObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyCompactUnicodeObject { pub _base: PyASCIIObject, pub utf8_length: Py_ssize_t, pub utf8: *mut ::std::os::raw::c_char, pub wstr_length: Py_ssize_t, } impl Default for PyCompactUnicodeObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct PyUnicodeObject { pub _base: PyCompactUnicodeObject, pub data: PyUnicodeObject__bindgen_ty_1, } #[repr(C)] #[derive(Copy, Clone)] pub union PyUnicodeObject__bindgen_ty_1 { pub any: *mut ::std::os::raw::c_void, pub latin1: *mut Py_UCS1, pub ucs2: *mut Py_UCS2, pub ucs4: *mut Py_UCS4, _bindgen_union_align: u64, } impl Default for PyUnicodeObject__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for PyUnicodeObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyLongObject = _longobject; #[cfg(target_pointer_width = "64")] pub type digit = u32; #[cfg(target_pointer_width = "32")] pub type digit = u16; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _longobject { pub ob_base: PyVarObject, pub ob_digit: [digit; 1usize], } impl Default for _longobject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyFloatObject { pub ob_base: PyObject, pub ob_fval: f64, } impl Default for PyFloatObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyTupleObject { pub ob_base: PyVarObject, pub ob_item: [*mut PyObject; 1usize], } impl Default for PyTupleObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyListObject { pub ob_base: PyVarObject, pub ob_item: *mut *mut PyObject, pub allocated: Py_ssize_t, } impl Default for PyListObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyDictKeysObject = _dictkeysobject; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyDictObject { pub ob_base: PyObject, pub ma_used: Py_ssize_t, pub ma_version_tag: u64, pub ma_keys: *mut PyDictKeysObject, pub ma_values: *mut *mut PyObject, } impl Default for PyDictObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyCFunction = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyMethodDef { pub ml_name: *const ::std::os::raw::c_char, pub ml_meth: PyCFunction, pub ml_flags: ::std::os::raw::c_int, pub ml_doc: *const ::std::os::raw::c_char, } impl Default for PyMethodDef { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type Py_OpenCodeHookFunction = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_void) -> *mut PyObject, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _PyOpcache { _unused: [u8; 0], } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyCodeObject { pub ob_base: PyObject, pub co_argcount: ::std::os::raw::c_int, pub co_posonlyargcount: ::std::os::raw::c_int, pub co_kwonlyargcount: ::std::os::raw::c_int, pub co_nlocals: ::std::os::raw::c_int, pub co_stacksize: ::std::os::raw::c_int, pub co_flags: ::std::os::raw::c_int, pub co_firstlineno: ::std::os::raw::c_int, pub co_code: *mut PyObject, pub co_consts: *mut PyObject, pub co_names: *mut PyObject, pub co_varnames: *mut PyObject, pub co_freevars: *mut PyObject, pub co_cellvars: *mut PyObject, pub co_cell2arg: *mut Py_ssize_t, pub co_filename: *mut PyObject, pub co_name: *mut PyObject, pub co_lnotab: *mut PyObject, pub co_zombieframe: *mut ::std::os::raw::c_void, pub co_weakreflist: *mut PyObject, pub co_extra: *mut ::std::os::raw::c_void, pub co_opcache_map: *mut ::std::os::raw::c_uchar, pub co_opcache: *mut _PyOpcache, pub co_opcache_flag: ::std::os::raw::c_int, pub co_opcache_size: ::std::os::raw::c_uchar, } impl Default for PyCodeObject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type PyFrameObject = _frame; pub type PyThreadState = _ts; pub type PyInterpreterState = _is; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyWideStringList { pub length: Py_ssize_t, pub items: *mut *mut wchar_t, } impl Default for PyWideStringList { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct PyPreConfig { pub _config_init: ::std::os::raw::c_int, pub parse_argv: ::std::os::raw::c_int, pub isolated: ::std::os::raw::c_int, pub use_environment: ::std::os::raw::c_int, pub configure_locale: ::std::os::raw::c_int, pub coerce_c_locale: ::std::os::raw::c_int, pub coerce_c_locale_warn: ::std::os::raw::c_int, pub utf8_mode: ::std::os::raw::c_int, pub dev_mode: ::std::os::raw::c_int, pub allocator: ::std::os::raw::c_int, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyConfig { pub _config_init: ::std::os::raw::c_int, pub isolated: ::std::os::raw::c_int, pub use_environment: ::std::os::raw::c_int, pub dev_mode: ::std::os::raw::c_int, pub install_signal_handlers: ::std::os::raw::c_int, pub use_hash_seed: ::std::os::raw::c_int, pub hash_seed: ::std::os::raw::c_ulong, pub faulthandler: ::std::os::raw::c_int, pub _use_peg_parser: ::std::os::raw::c_int, pub tracemalloc: ::std::os::raw::c_int, pub import_time: ::std::os::raw::c_int, pub show_ref_count: ::std::os::raw::c_int, pub dump_refs: ::std::os::raw::c_int, pub malloc_stats: ::std::os::raw::c_int, pub filesystem_encoding: *mut wchar_t, pub filesystem_errors: *mut wchar_t, pub pycache_prefix: *mut wchar_t, pub parse_argv: ::std::os::raw::c_int, pub argv: PyWideStringList, pub program_name: *mut wchar_t, pub xoptions: PyWideStringList, pub warnoptions: PyWideStringList, pub site_import: ::std::os::raw::c_int, pub bytes_warning: ::std::os::raw::c_int, pub inspect: ::std::os::raw::c_int, pub interactive: ::std::os::raw::c_int, pub optimization_level: ::std::os::raw::c_int, pub parser_debug: ::std::os::raw::c_int, pub write_bytecode: ::std::os::raw::c_int, pub verbose: ::std::os::raw::c_int, pub quiet: ::std::os::raw::c_int, pub user_site_directory: ::std::os::raw::c_int, pub configure_c_stdio: ::std::os::raw::c_int, pub buffered_stdio: ::std::os::raw::c_int, pub stdio_encoding: *mut wchar_t, pub stdio_errors: *mut wchar_t, pub check_hash_pycs_mode: *mut wchar_t, pub pathconfig_warnings: ::std::os::raw::c_int, pub pythonpath_env: *mut wchar_t, pub home: *mut wchar_t, pub module_search_paths_set: ::std::os::raw::c_int, pub module_search_paths: PyWideStringList, pub executable: *mut wchar_t, pub base_executable: *mut wchar_t, pub prefix: *mut wchar_t, pub base_prefix: *mut wchar_t, pub exec_prefix: *mut wchar_t, pub base_exec_prefix: *mut wchar_t, pub platlibdir: *mut wchar_t, pub skip_source_first_line: ::std::os::raw::c_int, pub run_command: *mut wchar_t, pub run_module: *mut wchar_t, pub run_filename: *mut wchar_t, pub _install_importlib: ::std::os::raw::c_int, pub _init_main: ::std::os::raw::c_int, pub _isolated_interpreter: ::std::os::raw::c_int, pub _orig_argv: PyWideStringList, } impl Default for PyConfig { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type Py_tracefunc = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyFrameObject, arg3: ::std::os::raw::c_int, arg4: *mut PyObject, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _err_stackitem { pub exc_type: *mut PyObject, pub exc_value: *mut PyObject, pub exc_traceback: *mut PyObject, pub previous_item: *mut _err_stackitem, } impl Default for _err_stackitem { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type _PyErr_StackItem = _err_stackitem; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _ts { pub prev: *mut _ts, pub next: *mut _ts, pub interp: *mut PyInterpreterState, pub frame: *mut PyFrameObject, pub recursion_depth: ::std::os::raw::c_int, pub overflowed: ::std::os::raw::c_char, pub recursion_critical: ::std::os::raw::c_char, pub stackcheck_counter: ::std::os::raw::c_int, pub tracing: ::std::os::raw::c_int, pub use_tracing: ::std::os::raw::c_int, pub c_profilefunc: Py_tracefunc, pub c_tracefunc: Py_tracefunc, pub c_profileobj: *mut PyObject, pub c_traceobj: *mut PyObject, pub curexc_type: *mut PyObject, pub curexc_value: *mut PyObject, pub curexc_traceback: *mut PyObject, pub exc_state: _PyErr_StackItem, pub exc_info: *mut _PyErr_StackItem, pub dict: *mut PyObject, pub gilstate_counter: ::std::os::raw::c_int, pub async_exc: *mut PyObject, pub thread_id: ::std::os::raw::c_ulong, pub trash_delete_nesting: ::std::os::raw::c_int, pub trash_delete_later: *mut PyObject, pub on_delete: ::std::option::Option, pub on_delete_data: *mut ::std::os::raw::c_void, pub coroutine_origin_tracking_depth: ::std::os::raw::c_int, pub async_gen_firstiter: *mut PyObject, pub async_gen_finalizer: *mut PyObject, pub context: *mut PyObject, pub context_ver: u64, pub id: u64, } impl Default for _ts { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type _PyFrameEvalFunction = ::std::option::Option< unsafe extern "C" fn( tstate: *mut PyThreadState, arg1: *mut PyFrameObject, arg2: ::std::os::raw::c_int, ) -> *mut PyObject, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _xid { pub data: *mut ::std::os::raw::c_void, pub obj: *mut PyObject, pub interp: i64, pub new_object: ::std::option::Option *mut PyObject>, pub free: ::std::option::Option, } impl Default for _xid { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type crossinterpdatafunc = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut _xid) -> ::std::os::raw::c_int, >; pub type getter = ::std::option::Option< unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut ::std::os::raw::c_void) -> *mut PyObject, >; pub type setter = ::std::option::Option< unsafe extern "C" fn( arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyGetSetDef { pub name: *const ::std::os::raw::c_char, pub get: getter, pub set: setter, pub doc: *const ::std::os::raw::c_char, pub closure: *mut ::std::os::raw::c_void, } impl Default for PyGetSetDef { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyMemberDef { _unused: [u8; 0], } pub type PyThread_type_lock = *mut ::std::os::raw::c_void; pub type Py_tss_t = _Py_tss_t; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_tss_t { pub _is_initialized: ::std::os::raw::c_int, pub _key: pthread_key_t, } pub type Py_AuditHookFunction = ::std::option::Option< unsafe extern "C" fn( arg1: *const ::std::os::raw::c_char, arg2: *mut PyObject, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int, >; pub const _Py_error_handler__Py_ERROR_UNKNOWN: _Py_error_handler = 0; pub const _Py_error_handler__Py_ERROR_STRICT: _Py_error_handler = 1; pub const _Py_error_handler__Py_ERROR_SURROGATEESCAPE: _Py_error_handler = 2; pub const _Py_error_handler__Py_ERROR_REPLACE: _Py_error_handler = 3; pub const _Py_error_handler__Py_ERROR_IGNORE: _Py_error_handler = 4; pub const _Py_error_handler__Py_ERROR_BACKSLASHREPLACE: _Py_error_handler = 5; pub const _Py_error_handler__Py_ERROR_SURROGATEPASS: _Py_error_handler = 6; pub const _Py_error_handler__Py_ERROR_XMLCHARREFREPLACE: _Py_error_handler = 7; pub const _Py_error_handler__Py_ERROR_OTHER: _Py_error_handler = 8; pub type _Py_error_handler = u32; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct PyTryBlock { pub b_type: ::std::os::raw::c_int, pub b_handler: ::std::os::raw::c_int, pub b_level: ::std::os::raw::c_int, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _frame { pub ob_base: PyVarObject, pub f_back: *mut _frame, pub f_code: *mut PyCodeObject, pub f_builtins: *mut PyObject, pub f_globals: *mut PyObject, pub f_locals: *mut PyObject, pub f_valuestack: *mut *mut PyObject, pub f_stacktop: *mut *mut PyObject, pub f_trace: *mut PyObject, pub f_trace_lines: ::std::os::raw::c_char, pub f_trace_opcodes: ::std::os::raw::c_char, pub f_gen: *mut PyObject, pub f_lasti: ::std::os::raw::c_int, pub f_lineno: ::std::os::raw::c_int, pub f_iblock: ::std::os::raw::c_int, pub f_executing: ::std::os::raw::c_char, pub f_blockstack: [PyTryBlock; 20usize], pub f_localsplus: [*mut PyObject; 1usize], } impl Default for _frame { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct PyDictKeyEntry { pub me_hash: Py_hash_t, pub me_key: *mut PyObject, pub me_value: *mut PyObject, } impl Default for PyDictKeyEntry { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type dict_lookup_func = ::std::option::Option< unsafe extern "C" fn( mp: *mut PyDictObject, key: *mut PyObject, hash: Py_hash_t, value_addr: *mut *mut PyObject, ) -> Py_ssize_t, >; #[repr(C)] #[derive(Debug)] pub struct _dictkeysobject { pub dk_refcnt: Py_ssize_t, pub dk_size: Py_ssize_t, pub dk_lookup: dict_lookup_func, pub dk_usable: Py_ssize_t, pub dk_nentries: Py_ssize_t, pub dk_indices: __IncompleteArrayField<::std::os::raw::c_char>, } impl Default for _dictkeysobject { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type atomic_int = u32; pub type atomic_uintptr_t = usize; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_atomic_address { pub _value: atomic_uintptr_t, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _Py_atomic_int { pub _value: atomic_int, } #[repr(C)] #[derive(Copy, Clone)] pub struct _gil_runtime_state { pub interval: ::std::os::raw::c_ulong, pub last_holder: _Py_atomic_address, pub locked: _Py_atomic_int, pub switch_number: ::std::os::raw::c_ulong, pub cond: pthread_cond_t, pub mutex: pthread_mutex_t, pub switch_cond: pthread_cond_t, pub switch_mutex: pthread_mutex_t, } impl Default for _gil_runtime_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _ceval_runtime_state { pub signals_pending: _Py_atomic_int, pub gil: _gil_runtime_state, } impl Default for _ceval_runtime_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _gilstate_runtime_state { pub check_enabled: ::std::os::raw::c_int, pub tstate_current: _Py_atomic_address, pub autoInterpreterState: *mut PyInterpreterState, pub autoTSSkey: Py_tss_t, } impl Default for _gilstate_runtime_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_AuditHookEntry { pub next: *mut _Py_AuditHookEntry, pub hookCFunction: Py_AuditHookFunction, pub userData: *mut ::std::os::raw::c_void, } impl Default for _Py_AuditHookEntry { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct pyruntimestate { pub preinitializing: ::std::os::raw::c_int, pub preinitialized: ::std::os::raw::c_int, pub core_initialized: ::std::os::raw::c_int, pub initialized: ::std::os::raw::c_int, pub _finalizing: _Py_atomic_address, pub interpreters: pyruntimestate_pyinterpreters, pub xidregistry: pyruntimestate__xidregistry, pub main_thread: ::std::os::raw::c_ulong, pub exitfuncs: [::std::option::Option; 32usize], pub nexitfuncs: ::std::os::raw::c_int, pub ceval: _ceval_runtime_state, pub gilstate: _gilstate_runtime_state, pub preconfig: PyPreConfig, pub open_code_hook: Py_OpenCodeHookFunction, pub open_code_userdata: *mut ::std::os::raw::c_void, pub audit_hook_head: *mut _Py_AuditHookEntry, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct pyruntimestate_pyinterpreters { pub mutex: PyThread_type_lock, pub head: *mut PyInterpreterState, pub main: *mut PyInterpreterState, pub next_id: i64, } impl Default for pyruntimestate_pyinterpreters { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct pyruntimestate__xidregistry { pub mutex: PyThread_type_lock, pub head: *mut _xidregitem, } impl Default for pyruntimestate__xidregistry { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for pyruntimestate { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct PyGC_Head { pub _gc_next: usize, pub _gc_prev: usize, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct gc_generation { pub head: PyGC_Head, pub threshold: ::std::os::raw::c_int, pub count: ::std::os::raw::c_int, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct gc_generation_stats { pub collections: Py_ssize_t, pub collected: Py_ssize_t, pub uncollectable: Py_ssize_t, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _gc_runtime_state { pub trash_delete_later: *mut PyObject, pub trash_delete_nesting: ::std::os::raw::c_int, pub enabled: ::std::os::raw::c_int, pub debug: ::std::os::raw::c_int, pub generations: [gc_generation; 3usize], pub generation0: *mut PyGC_Head, pub permanent_generation: gc_generation, pub generation_stats: [gc_generation_stats; 3usize], pub collecting: ::std::os::raw::c_int, pub garbage: *mut PyObject, pub callbacks: *mut PyObject, pub long_lived_total: Py_ssize_t, pub long_lived_pending: Py_ssize_t, } impl Default for _gc_runtime_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _warnings_runtime_state { pub filters: *mut PyObject, pub once_registry: *mut PyObject, pub default_action: *mut PyObject, pub filters_version: ::std::os::raw::c_long, } impl Default for _warnings_runtime_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _pending_calls { pub lock: PyThread_type_lock, pub calls_to_do: _Py_atomic_int, pub async_exc: ::std::os::raw::c_int, pub calls: [_pending_calls__bindgen_ty_1; 32usize], pub first: ::std::os::raw::c_int, pub last: ::std::os::raw::c_int, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _pending_calls__bindgen_ty_1 { pub func: ::std::option::Option< unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, >, pub arg: *mut ::std::os::raw::c_void, } impl Default for _pending_calls__bindgen_ty_1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } impl Default for _pending_calls { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _ceval_state { pub recursion_limit: ::std::os::raw::c_int, pub tracing_possible: ::std::os::raw::c_int, pub eval_breaker: _Py_atomic_int, pub gil_drop_request: _Py_atomic_int, pub pending: _pending_calls, } impl Default for _ceval_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_unicode_fs_codec { pub encoding: *mut ::std::os::raw::c_char, pub utf8: ::std::os::raw::c_int, pub errors: *mut ::std::os::raw::c_char, pub error_handler: _Py_error_handler, } impl Default for _Py_unicode_fs_codec { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _Py_unicode_state { pub fs_codec: _Py_unicode_fs_codec, } impl Default for _Py_unicode_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy, Clone)] pub struct _is { pub next: *mut _is, pub tstate_head: *mut _ts, pub runtime: *mut pyruntimestate, pub id: i64, pub id_refcount: i64, pub requires_idref: ::std::os::raw::c_int, pub id_mutex: PyThread_type_lock, pub finalizing: ::std::os::raw::c_int, pub ceval: _ceval_state, pub gc: _gc_runtime_state, pub modules: *mut PyObject, pub modules_by_index: *mut PyObject, pub sysdict: *mut PyObject, pub builtins: *mut PyObject, pub importlib: *mut PyObject, pub num_threads: ::std::os::raw::c_long, pub pythread_stacksize: usize, pub codec_search_path: *mut PyObject, pub codec_search_cache: *mut PyObject, pub codec_error_registry: *mut PyObject, pub codecs_initialized: ::std::os::raw::c_int, pub unicode: _Py_unicode_state, pub config: PyConfig, pub dlopenflags: ::std::os::raw::c_int, pub dict: *mut PyObject, pub builtins_copy: *mut PyObject, pub import_func: *mut PyObject, pub eval_frame: _PyFrameEvalFunction, pub co_extra_user_count: Py_ssize_t, pub co_extra_freefuncs: [freefunc; 255usize], pub before_forkers: *mut PyObject, pub after_forkers_parent: *mut PyObject, pub after_forkers_child: *mut PyObject, pub pyexitfunc: ::std::option::Option, pub pyexitmodule: *mut PyObject, pub tstate_next_unique_id: u64, pub warnings: _warnings_runtime_state, pub audit_hooks: *mut PyObject, pub parser: _is__bindgen_ty_1, pub small_ints: [*mut PyLongObject; 262usize], } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _is__bindgen_ty_1 { pub listnode: _is__bindgen_ty_1__bindgen_ty_1, } #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _is__bindgen_ty_1__bindgen_ty_1 { pub level: ::std::os::raw::c_int, pub atbol: ::std::os::raw::c_int, } impl Default for _is { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _xidregitem { pub cls: *mut PyTypeObject, pub getdata: crossinterpdatafunc, pub next: *mut _xidregitem, } impl Default for _xidregitem { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } ================================================ FILE: src/python_data_access.rs ================================================ #![allow(clippy::unnecessary_cast)] use anyhow::Error; use crate::python_bindings::v3_13_0; use crate::python_interpreters::{ BytesObject, InterpreterState, ListObject, Object, StringObject, TupleObject, TypeObject, }; use crate::utils::offset_of; use crate::version::Version; use remoteprocess::ProcessMemory; /// Copies a string from a target process. Attempts to handle unicode differences, which mostly seems to be working pub fn copy_string( ptr: *const T, process: &P, ) -> Result { let obj = process.copy_pointer(ptr)?; if obj.size() == 0 { return Ok(String::new()); } if obj.size() >= 4096 { return Err(format_err!( "Refusing to copy {} chars of a string", obj.size() )); } let kind = obj.kind(); let bytes = process.copy(obj.address(ptr as usize), obj.size() * kind as usize)?; match (kind, obj.ascii()) { (4, _) => { #[allow(clippy::cast_ptr_alignment)] let chars = unsafe { std::slice::from_raw_parts(bytes.as_ptr() as *const char, bytes.len() / 4) }; Ok(chars.iter().collect()) } (2, _) => { #[allow(clippy::cast_ptr_alignment)] let chars = unsafe { std::slice::from_raw_parts(bytes.as_ptr() as *const u16, bytes.len() / 2) }; Ok(String::from_utf16(chars)?) } (1, true) => Ok(String::from_utf8(bytes)?), (1, false) => Ok(bytes.iter().map(|&b| b as char).collect()), _ => Err(format_err!("Unknown string kind {}", kind)), } } /// Copies data from a PyBytesObject (currently only lnotab object) pub fn copy_bytes( ptr: *const T, process: &P, ) -> Result, Error> { let obj = process.copy_pointer(ptr)?; let size = obj.size(); if size >= 65536 { return Err(format_err!("Refusing to copy {} bytes", size)); } Ok(process.copy(obj.address(ptr as usize), size as usize)?) } /// Copies a i64 from a PyLongObject. Returns the value + if it overflowed pub fn copy_long( process: &P, version: &Version, addr: usize, ) -> Result<(i64, bool), Error> { let (size, negative, digit, value_size) = match version { Version { major: 3, minor: 12..=13, .. } => { // PyLongObject format changed in python 3.12 let value = process .copy_pointer(addr as *const crate::python_bindings::v3_12_0::PyLongObject)?; let size = value.long_value.lv_tag >> 3; let negative: i64 = if (value.long_value.lv_tag & 3) == 2 { -1 } else { 1 }; ( size, negative, value.long_value.ob_digit[0] as u32, std::mem::size_of_val(&value), ) } _ => { // this is PyLongObject for a specific version of python, but this works since it's binary compatible // layout across versions we're targeting let value = process .copy_pointer(addr as *const crate::python_bindings::v3_7_0::PyLongObject)?; let negative: i64 = if value.ob_base.ob_size < 0 { -1 } else { 1 }; let size = (value.ob_base.ob_size * (negative as isize)) as usize; ( size, negative, value.ob_digit[0] as u32, std::mem::size_of_val(&value), ) } }; match size { 0 => Ok((0, false)), 1 => Ok((negative * (digit as i64), false)), #[cfg(target_pointer_width = "64")] 2 => { let digits: [u32; 2] = process.copy_struct(addr + value_size - 8)?; let mut ret: i64 = 0; for i in 0..size { ret += (digits[i as usize] as i64) << (30 * i); } Ok((negative * ret, false)) } #[cfg(target_pointer_width = "32")] 2..=4 => { let digits: [u16; 4] = process.copy_struct(addr + value_size - 4)?; let mut ret: i64 = 0; for i in 0..size { ret += (digits[i as usize] as i64) << (15 * i); } Ok((negative * ret, false)) } // we don't support arbitrary sized integers yet, signal this by returning that we've overflowed _ => Ok((size as i64, true)), } } /// Copies a i64 from a python 2.7 PyIntObject pub fn copy_int(process: &P, addr: usize) -> Result { let value = process.copy_pointer(addr as *const crate::python_bindings::v2_7_15::PyIntObject)?; Ok(value.ob_ival as i64) } /// Allows iteration of a python dictionary. Only supports python 3.6+ right now pub struct DictIterator<'a, P: 'a> { process: &'a P, entries_addr: usize, kind: u8, index: usize, entries: usize, values: usize, } impl<'a, P: ProcessMemory> DictIterator<'a, P> { pub fn from_managed_dict( process: &'a P, version: &'a Version, addr: usize, tp_addr: usize, flags: usize, ) -> Result, Error> { // Handles logic of _PyObject_ManagedDictPointer in python 3.11 let mut values_addr: usize = process.copy_struct(addr - 4 * std::mem::size_of::())?; // TODO: MANAGED_DICT_OFFSET is -3 if GIL isn't disabled, -1 otherwise (in py3.13+) // handle gil-less python branches let mut dict_addr: usize = process.copy_struct(addr - 3 * std::mem::size_of::())?; // for python 3.12, the values/dict are combined into a single tagged pointer if version.major == 3 && version.minor == 12 { if dict_addr & 1 == 0 { values_addr = 0; } else { values_addr = dict_addr + 1; dict_addr = 0; } } if values_addr != 0 { let ht_cached_keys = if version.major == 3 && version.minor >= 12 { let ht: crate::python_bindings::v3_12_0::PyHeapTypeObject = process.copy_struct(tp_addr)?; ht.ht_cached_keys as usize } else { let ht: crate::python_bindings::v3_11_0::PyHeapTypeObject = process.copy_struct(tp_addr)?; ht.ht_cached_keys as usize }; // handle inline values in py3.13+ // https://github.com/python/cpython/issues/115776 if flags & PY_TPFLAGS_INLINE_VALUES != 0 { // PyDictValues is stored inline after the initial PyObject let dict_values: v3_13_0::_dictvalues = Default::default(); let values_offset = offset_of(&dict_values, &dict_values.values); values_addr = addr + std::mem::size_of::() + values_offset; } let keys: crate::python_bindings::v3_12_0::PyDictKeysObject = process.copy_struct(ht_cached_keys as usize)?; let entries_addr = ht_cached_keys as usize + (1 << keys.dk_log2_index_bytes) + std::mem::size_of_val(&keys); Ok(DictIterator { process, entries_addr, index: 0, kind: keys.dk_kind, entries: keys.dk_nentries as usize, values: values_addr, }) } else if dict_addr != 0 { DictIterator::from(process, version, dict_addr) } else { Err(format_err!("neither values or dict is set in managed dict")) } } pub fn from( process: &'a P, version: &'a Version, addr: usize, ) -> Result, Error> { match version { Version { major: 3, minor: 11..=13, .. } => { let dict: crate::python_bindings::v3_11_0::PyDictObject = process.copy_struct(addr)?; let keys = process.copy_pointer(dict.ma_keys)?; let entries_addr = dict.ma_keys as usize + (1 << keys.dk_log2_index_bytes) + std::mem::size_of_val(&keys); Ok(DictIterator { process, entries_addr, index: 0, kind: keys.dk_kind, entries: keys.dk_nentries as usize, values: dict.ma_values as usize, }) } _ => { let dict: crate::python_bindings::v3_7_0::PyDictObject = process.copy_struct(addr)?; // Getting this going generically is tricky: there is a lot of variation on how dictionaries are handled // instead this just focuses on a single version, which works for python // 3.6/3.7/3.8/3.9/3.10 let keys = process.copy_pointer(dict.ma_keys)?; let index_size = match keys.dk_size { 0..=0xff => 1, 0..=0xffff => 2, #[cfg(target_pointer_width = "64")] 0..=0xffffffff => 4, #[cfg(target_pointer_width = "64")] _ => 8, #[cfg(not(target_pointer_width = "64"))] _ => 4, }; let byteoffset = (keys.dk_size * index_size) as usize; let entries_addr = dict.ma_keys as usize + byteoffset + std::mem::size_of_val(&keys); Ok(DictIterator { process, entries_addr, index: 0, kind: 0, entries: keys.dk_nentries as usize, values: dict.ma_values as usize, }) } } } } impl<'a, P: ProcessMemory> Iterator for DictIterator<'a, P> { type Item = Result<(usize, usize), Error>; fn next(&mut self) -> Option { while self.index < self.entries { let index = self.index; self.index += 1; // get the addresses of the key/value for the current index let entry = match self.kind { 0 => { let addr = index * std::mem::size_of::() + self.entries_addr; let ret = self .process .copy_struct::(addr); ret.map(|entry| (entry.me_key as usize, entry.me_value as usize)) } _ => { // Python 3.11 added a PyDictUnicodeEntry , which uses the hash from the Unicode key rather than recalculate let addr = index * std::mem::size_of::( ) + self.entries_addr; let ret = self .process .copy_struct::(addr); ret.map(|entry| (entry.me_key as usize, entry.me_value as usize)) } }; match entry { Ok((key, value)) => { if key == 0 { continue; } let value = if self.values != 0 { let valueaddr = self.values + index * std::mem::size_of::<*mut crate::python_bindings::v3_7_0::PyObject>( ); match self.process.copy_struct(valueaddr) { Ok(addr) => addr, Err(e) => { return Some(Err(e.into())); } } } else { value }; return Some(Ok((key, value))); } Err(e) => return Some(Err(e.into())), } } None } } pub const PY_TPFLAGS_INLINE_VALUES: usize = 1 << 2; pub const PY_TPFLAGS_MANAGED_DICT: usize = 1 << 4; const PY_TPFLAGS_INT_SUBCLASS: usize = 1 << 23; const PY_TPFLAGS_LONG_SUBCLASS: usize = 1 << 24; const PY_TPFLAGS_LIST_SUBCLASS: usize = 1 << 25; const PY_TPFLAGS_TUPLE_SUBCLASS: usize = 1 << 26; const PY_TPFLAGS_BYTES_SUBCLASS: usize = 1 << 27; const PY_TPFLAGS_STRING_SUBCLASS: usize = 1 << 28; const PY_TPFLAGS_DICT_SUBCLASS: usize = 1 << 29; /// Converts a python variable in the other process to a human readable string pub fn format_variable( process: &P, version: &Version, addr: usize, max_length: isize, ) -> Result where I: InterpreterState, P: ProcessMemory, { // We need at least 5 characters remaining for all this code to work, replace with an ellipsis if // we're out of space if max_length <= 5 { return Ok("...".to_owned()); } let value: I::Object = process.copy_struct(addr)?; let value_type = process.copy_pointer(value.ob_type())?; // get the typename (truncating to 128 bytes if longer) let max_type_len = 128; let value_type_name = process.copy(value_type.name() as usize, max_type_len)?; let length = value_type_name .iter() .position(|&x| x == 0) .unwrap_or(max_type_len); let value_type_name = std::str::from_utf8(&value_type_name[..length])?; let format_int = |value: i64| { if value_type_name == "bool" { (if value > 0 { "True" } else { "False" }).to_owned() } else { format!("{value}") } }; // use the flags/typename to figure out how to stringify this object let flags = value_type.flags(); let formatted = if flags & PY_TPFLAGS_INT_SUBCLASS != 0 { format_int(copy_int(process, addr)?) } else if flags & PY_TPFLAGS_LONG_SUBCLASS != 0 { // we don't handle arbitrary sized integer values (max is 2**60) let (value, overflowed) = copy_long(process, version, addr)?; if overflowed { if value > 0 { "+bigint".to_owned() } else { "-bigint".to_owned() } } else { format_int(value) } } else if flags & PY_TPFLAGS_STRING_SUBCLASS != 0 || (version.major == 2 && (flags & PY_TPFLAGS_BYTES_SUBCLASS != 0)) { let value = copy_string(addr as *const I::StringObject, process)? .replace('\'', "\\\"") .replace('\n', "\\n"); if let Some((offset, _)) = value.char_indices().nth((max_length - 5) as usize) { format!("\"{}...\"", &value[..offset]) } else { format!("\"{value}\"") } } else if flags & PY_TPFLAGS_DICT_SUBCLASS != 0 { if version.major == 3 && version.minor >= 6 { let mut values = Vec::new(); let mut remaining = max_length - 2; for entry in DictIterator::from(process, version, addr)? { let (key, value) = entry?; let key = format_variable::(process, version, key, remaining)?; let value = format_variable::(process, version, value, remaining)?; remaining -= (key.len() + value.len()) as isize + 4; if remaining <= 5 { values.push("...".to_owned()); break; } values.push(format!("{key}: {value}")); } format!("{{{}}}", values.join(", ")) } else { // TODO: support getting dictionaries from older versions of python "dict".to_owned() } } else if flags & PY_TPFLAGS_LIST_SUBCLASS != 0 { let object: I::ListObject = process.copy_struct(addr)?; let addr = object.item() as usize; let mut values = Vec::new(); let mut remaining = max_length - 2; for i in 0..object.size() { let valueptr: *mut I::Object = process.copy_struct(addr + i * std::mem::size_of::<*mut I::Object>())?; let value = format_variable::(process, version, valueptr as usize, remaining)?; remaining -= value.len() as isize + 2; if remaining <= 5 { values.push("...".to_owned()); break; } values.push(value); } format!("[{}]", values.join(", ")) } else if flags & PY_TPFLAGS_TUPLE_SUBCLASS != 0 { let object: I::TupleObject = process.copy_struct(addr)?; let mut values = Vec::new(); let mut remaining = max_length - 2; for i in 0..object.size() { let value_addr: *mut I::Object = process.copy_struct(object.address(addr, i))?; let value = format_variable::(process, version, value_addr as usize, remaining)?; remaining -= value.len() as isize + 2; if remaining <= 5 { values.push("...".to_owned()); break; } values.push(value); } format!("({})", values.join(", ")) } else if value_type_name == "float" { let value = process.copy_pointer(addr as *const crate::python_bindings::v3_7_0::PyFloatObject)?; format!("{}", value.ob_fval) } else if value_type_name == "NoneType" { "None".to_owned() } else if value_type_name.starts_with("numpy.") { match value_type_name { "numpy.bool" => format_obval::(addr, process)?, "numpy.uint8" => format_obval::(addr, process)?, "numpy.uint16" => format_obval::(addr, process)?, "numpy.uint32" => format_obval::(addr, process)?, "numpy.uint64" => format_obval::(addr, process)?, "numpy.int8" => format_obval::(addr, process)?, "numpy.int16" => format_obval::(addr, process)?, "numpy.int32" => format_obval::(addr, process)?, "numpy.int64" => format_obval::(addr, process)?, "numpy.float32" => format_obval::(addr, process)?, "numpy.float64" => format_obval::(addr, process)?, _ => format!("<{value_type_name} at 0x{addr:x}>"), } } else { format!("<{value_type_name} at 0x{addr:x}>") }; Ok(formatted) } /// Format the numpy scalar to a string. /// /// All numpy scalars have shape: /// { /// ob_base: PyObject, /// obval: , /// } /// /// Where `obval` can be of different sizes depending on the scalar type. /// We match the size to the value_type_name for this purpose, avoiding the /// need to build bindings for the numpy C API. /// /// * `addr`: Address of the numpy scalar /// * `process`: Process memory in which the object resides fn format_obval(addr: usize, process: &P) -> Result where T: std::fmt::Display + Copy, P: ProcessMemory, { let base_addr = addr as *mut u32; let offset = std::mem::size_of::() as isize; let result = unsafe { process.copy_pointer(base_addr.byte_offset(offset) as *const T)? }; Ok(format!("{result}")) } #[cfg(test)] pub mod tests { // the idea here is to create various cpython interpretator structs locally // and then test out that the above code handles appropriately use super::*; use crate::python_bindings::v3_7_0::{ PyASCIIObject, PyBytesObject, PyUnicodeObject, PyVarObject, }; use remoteprocess::LocalProcess; use std::ptr::copy_nonoverlapping; // python stores data after pybytesobject/pyasciiobject. hack by initializing a 4k buffer for testing. // TODO: get better at Rust and figure out a better solution #[allow(dead_code)] #[repr(C)] pub struct AllocatedPyByteObject { pub base: PyBytesObject, pub storage: [u8; 4096], } #[allow(dead_code)] #[repr(C)] // Rust can optimize the layout of this struct and break our pointer arithmetic pub struct AllocatedPyASCIIObject { pub base: PyASCIIObject, pub storage: [u8; 4096], } pub fn to_byteobject(bytes: &[u8]) -> AllocatedPyByteObject { let ob_size = bytes.len() as isize; let base = PyBytesObject { ob_base: PyVarObject { ob_size, ..Default::default() }, ..Default::default() }; let mut ret = AllocatedPyByteObject { base, storage: [0 as u8; 4096], }; unsafe { copy_nonoverlapping( bytes.as_ptr(), ret.base.ob_sval.as_mut_ptr() as *mut u8, bytes.len(), ); } ret } pub fn to_asciiobject(input: &str) -> AllocatedPyASCIIObject { let bytes: Vec = input.bytes().collect(); let mut base = PyASCIIObject { length: bytes.len() as isize, ..Default::default() }; base.state.set_compact(1); base.state.set_kind(1); base.state.set_ascii(1); let mut ret = AllocatedPyASCIIObject { base, storage: [0 as u8; 4096], }; unsafe { let ptr = &mut ret as *mut AllocatedPyASCIIObject as *mut u8; let dst = ptr.offset(std::mem::size_of::() as isize); copy_nonoverlapping(bytes.as_ptr(), dst, bytes.len()); } ret } #[test] fn test_copy_string() { let original = "function_name"; let obj = to_asciiobject(original); let unicode: &PyUnicodeObject = unsafe { std::mem::transmute(&obj.base) }; let copied = copy_string(unicode, &LocalProcess).unwrap(); assert_eq!(copied, original); } #[test] fn test_copy_bytes() { let original = [10_u8, 20, 30, 40, 50, 70, 80]; let bytes = to_byteobject(&original); let copied = copy_bytes(&bytes.base, &LocalProcess).unwrap(); assert_eq!(copied, original); } } ================================================ FILE: src/python_interpreters.rs ================================================ /* This code abstracts over different python interpreters by providing traits for the classes/methods we need and implementations on the bindings objects from bindgen. Note this code is unaware of copying memory from the target process, so the pointer addresses here refer to locations in the target process memory space. This means we can't dereference them directly. */ #![allow(clippy::unnecessary_cast)] // these bindings are automatically generated by rust bindgen // using the generate_bindings.py script use crate::python_bindings::{ v2_7_15, v3_10_0, v3_11_0, v3_12_0, v3_13_0, v3_3_7, v3_5_5, v3_6_6, v3_7_0, v3_8_0, v3_9_5, }; use crate::utils::offset_of; pub trait InterpreterState: Copy { type ThreadState: ThreadState; type Object: Object; type StringObject: StringObject; type ListObject: ListObject; type TupleObject: TupleObject; const HAS_GIL_RUNTIME_STATE: bool = false; /// Get a remote pointer to a pointer to PyThreadState. fn threadstate_ptr_ptr(interpreter_address: usize) -> *const *const Self::ThreadState; /// Get a remote pointer to a pointer to PyObject being the modules dict. fn modules_ptr_ptr(interpreter_address: usize) -> *const *const Self::Object; } pub trait ThreadState: Copy { type FrameObject: FrameObject; type InterpreterState: InterpreterState; fn interp(&self) -> *mut Self::InterpreterState; // starting in python 3.11, there is an extra level of indirection // in getting the frame. this returns the address fn frame_address(&self) -> Option; fn frame(&self, offset: Option) -> *mut Self::FrameObject; fn thread_id(&self) -> u64; fn native_thread_id(&self) -> Option; fn next(&self) -> *mut Self; } pub trait FrameObject: Copy { type CodeObject: CodeObject; fn code(&self) -> *mut Self::CodeObject; fn lasti(&self) -> i32; fn back(&self) -> *mut Self; fn is_entry(&self) -> bool; } pub trait CodeObject: Copy { type StringObject: StringObject; type BytesObject: BytesObject; type TupleObject: TupleObject; fn name(&self) -> *mut Self::StringObject; fn filename(&self) -> *mut Self::StringObject; fn line_table(&self) -> *mut Self::BytesObject; fn first_lineno(&self) -> i32; fn nlocals(&self) -> i32; fn argcount(&self) -> i32; fn varnames(&self) -> *mut Self::TupleObject; fn get_line_number(&self, lasti: i32, table: &[u8]) -> i32; } pub trait BytesObject: Copy { fn size(&self) -> usize; fn address(&self, base: usize) -> usize; } pub trait StringObject: Copy { fn ascii(&self) -> bool; fn kind(&self) -> u32; fn size(&self) -> usize; fn address(&self, base: usize) -> usize; } pub trait TupleObject: Copy { fn size(&self) -> usize; fn address(&self, base: usize, index: usize) -> usize; } pub trait ListObject: Copy { type Object: Object; fn size(&self) -> usize; fn item(&self) -> *mut *mut Self::Object; } pub trait Object: Copy { type TypeObject: TypeObject; fn ob_type(&self) -> *mut Self::TypeObject; } pub trait TypeObject: Copy { fn name(&self) -> *const ::std::os::raw::c_char; fn dictoffset(&self) -> isize; fn flags(&self) -> usize; } /// This macro provides a common impl for PyThreadState/PyFrameObject/PyCodeObject traits /// (this code is identical across python versions, we are only abstracting the struct layouts here). /// String handling changes substantially between python versions, and is handled separately. macro_rules! PythonCommonImpl { ($py: ident, $stringobject: ident) => { impl InterpreterState for $py::PyInterpreterState { type ThreadState = $py::PyThreadState; type Object = $py::PyObject; type StringObject = $py::$stringobject; type ListObject = $py::PyListObject; type TupleObject = $py::PyTupleObject; fn threadstate_ptr_ptr(interpreter_address: usize) -> *const *const Self::ThreadState { (interpreter_address + std::mem::offset_of!(Self, tstate_head)) as *const *const Self::ThreadState } fn modules_ptr_ptr(interpreter_address: usize) -> *const *const Self::Object { (interpreter_address + std::mem::offset_of!(Self, modules)) as *const *const Self::Object } } impl ThreadState for $py::PyThreadState { type FrameObject = $py::PyFrameObject; type InterpreterState = $py::PyInterpreterState; fn frame_address(&self) -> Option { None } fn frame(&self, _: Option) -> *mut Self::FrameObject { self.frame } fn thread_id(&self) -> u64 { self.thread_id as u64 } fn native_thread_id(&self) -> Option { None } fn next(&self) -> *mut Self { self.next } fn interp(&self) -> *mut Self::InterpreterState { self.interp } } impl FrameObject for $py::PyFrameObject { type CodeObject = $py::PyCodeObject; fn code(&self) -> *mut Self::CodeObject { self.f_code } fn lasti(&self) -> i32 { self.f_lasti as i32 } fn back(&self) -> *mut Self { self.f_back } fn is_entry(&self) -> bool { true } } impl Object for $py::PyObject { type TypeObject = $py::PyTypeObject; fn ob_type(&self) -> *mut Self::TypeObject { self.ob_type as *mut Self::TypeObject } } impl TypeObject for $py::PyTypeObject { fn name(&self) -> *const ::std::os::raw::c_char { self.tp_name } fn dictoffset(&self) -> isize { self.tp_dictoffset } fn flags(&self) -> usize { self.tp_flags as usize } } }; } // We can use this up until python3.10 - where code object lnotab attribute is deprecated macro_rules! PythonCodeObjectImpl { ($py: ident, $bytesobject: ident, $stringobject: ident) => { impl CodeObject for $py::PyCodeObject { type BytesObject = $py::$bytesobject; type StringObject = $py::$stringobject; type TupleObject = $py::PyTupleObject; fn name(&self) -> *mut Self::StringObject { self.co_name as *mut Self::StringObject } fn filename(&self) -> *mut Self::StringObject { self.co_filename as *mut Self::StringObject } fn line_table(&self) -> *mut Self::BytesObject { self.co_lnotab as *mut Self::BytesObject } fn first_lineno(&self) -> i32 { self.co_firstlineno } fn nlocals(&self) -> i32 { self.co_nlocals } fn argcount(&self) -> i32 { self.co_argcount } fn varnames(&self) -> *mut Self::TupleObject { self.co_varnames as *mut Self::TupleObject } fn get_line_number(&self, lasti: i32, table: &[u8]) -> i32 { let lasti = lasti as i32; // unpack the line table. format is specified here: // https://github.com/python/cpython/blob/3.9/Objects/lnotab_notes.txt let size = table.len(); let mut i = 0; let mut line_number: i32 = self.first_lineno(); let mut bytecode_address: i32 = 0; while (i + 1) < size { bytecode_address += i32::from(table[i]); if bytecode_address > lasti { break; } let mut increment = i32::from(table[i + 1]); // Handle negative line increments in the line number table - as shown here: // https://github.com/python/cpython/blob/143a97f6/Objects/lnotab_notes.txt#L48-L49 if increment >= 0x80 { increment -= 0x100; } line_number += increment; i += 2; } line_number } } }; } fn read_varint(index: &mut usize, table: &[u8]) -> Option { if *index >= table.len() { return None; } let mut ret: usize; let mut byte = table[*index]; let mut shift = 0; *index += 1; ret = (byte & 63) as usize; while byte & 64 != 0 { if *index >= table.len() { return None; } byte = table[*index]; *index += 1; shift += 6; ret += ((byte & 63) as usize) << shift; } Some(ret) } fn read_signed_varint(index: &mut usize, table: &[u8]) -> Option { let unsigned_val = read_varint(index, table)?; if unsigned_val & 1 != 0 { Some(-((unsigned_val >> 1) as isize)) } else { Some((unsigned_val >> 1) as isize) } } // Use for 3.11 and 3.12 macro_rules! CompactCodeObjectImpl { ($py: ident, $bytesobject: ident, $stringobject: ident) => { impl CodeObject for $py::PyCodeObject { type BytesObject = $py::$bytesobject; type StringObject = $py::$stringobject; type TupleObject = $py::PyTupleObject; fn name(&self) -> *mut Self::StringObject { self.co_name as *mut Self::StringObject } fn filename(&self) -> *mut Self::StringObject { self.co_filename as *mut Self::StringObject } fn line_table(&self) -> *mut Self::BytesObject { self.co_linetable as *mut Self::BytesObject } fn first_lineno(&self) -> i32 { self.co_firstlineno } fn nlocals(&self) -> i32 { self.co_nlocals } fn argcount(&self) -> i32 { self.co_argcount } fn varnames(&self) -> *mut Self::TupleObject { self.co_localsplusnames as *mut Self::TupleObject } fn get_line_number(&self, lasti: i32, table: &[u8]) -> i32 { // unpack compressed table format from python 3.11 // https://github.com/python/cpython/pull/91666/files let lasti = lasti - offset_of(self, &self.co_code_adaptive) as i32; let mut line_number: i32 = self.first_lineno(); let mut bytecode_address: i32 = 0; let mut index: usize = 0; loop { if index >= table.len() { break; } let byte = table[index]; index += 1; let delta = ((byte & 7) as i32) + 1; bytecode_address += delta * 2; let code = (byte >> 3) & 15; let line_delta = match code { 15 => 0, 14 => { let delta = read_signed_varint(&mut index, table).unwrap_or(0); read_varint(&mut index, table); // end line read_varint(&mut index, table); // start column read_varint(&mut index, table); // end column delta } 13 => read_signed_varint(&mut index, table).unwrap_or(0), 10..=12 => { index += 2; // start column / end column (code - 10).into() } _ => { index += 1; // column 0 } }; line_number += line_delta as i32; if bytecode_address >= lasti { break; } } line_number } } }; } // String/Byte/List/Tuple handling for Python 3.3+ macro_rules! Python3Impl { ($py: ident) => { impl BytesObject for $py::PyBytesObject { fn size(&self) -> usize { self.ob_base.ob_size as usize } fn address(&self, base: usize) -> usize { base + offset_of(self, &self.ob_sval) } } impl StringObject for $py::PyUnicodeObject { fn ascii(&self) -> bool { self._base._base.state.ascii() != 0 } fn size(&self) -> usize { self._base._base.length as usize } fn kind(&self) -> u32 { self._base._base.state.kind() } fn address(&self, base: usize) -> usize { if self._base._base.state.compact() == 0 { return unsafe { self.data.any as usize }; } if self._base._base.state.ascii() == 1 { base + std::mem::size_of::<$py::PyASCIIObject>() } else { base + std::mem::size_of::<$py::PyCompactUnicodeObject>() } } } impl ListObject for $py::PyListObject { type Object = $py::PyObject; fn size(&self) -> usize { self.ob_base.ob_size as usize } fn item(&self) -> *mut *mut Self::Object { self.ob_item } } impl TupleObject for $py::PyTupleObject { fn size(&self) -> usize { self.ob_base.ob_size as usize } fn address(&self, base: usize, index: usize) -> usize { base + offset_of(self, &self.ob_item) + index * std::mem::size_of::<*mut $py::PyObject>() } } }; } // Python 3.13 Python3Impl!(v3_13_0); impl InterpreterState for v3_13_0::PyInterpreterState { type ThreadState = v3_13_0::PyThreadState; type Object = v3_13_0::PyObject; type StringObject = v3_13_0::PyUnicodeObject; type ListObject = v3_13_0::PyListObject; type TupleObject = v3_13_0::PyTupleObject; const HAS_GIL_RUNTIME_STATE: bool = true; fn threadstate_ptr_ptr(interpreter_address: usize) -> *const *const Self::ThreadState { (interpreter_address + std::mem::offset_of!(Self, threads.head)) as *const *const Self::ThreadState } fn modules_ptr_ptr(interpreter_address: usize) -> *const *const Self::Object { (interpreter_address + std::mem::offset_of!(Self, imports.modules)) as *const *const Self::Object } } impl ThreadState for v3_13_0::PyThreadState { type FrameObject = v3_13_0::_PyInterpreterFrame; type InterpreterState = v3_13_0::PyInterpreterState; fn frame_address(&self) -> Option { None } fn frame(&self, _addr: Option) -> *mut Self::FrameObject { self.current_frame } fn thread_id(&self) -> u64 { self.thread_id as u64 } fn native_thread_id(&self) -> Option { Some(self.native_thread_id as u64) } fn next(&self) -> *mut Self { self.next } fn interp(&self) -> *mut Self::InterpreterState { self.interp } } impl FrameObject for v3_13_0::_PyInterpreterFrame { type CodeObject = v3_13_0::PyCodeObject; fn code(&self) -> *mut Self::CodeObject { self.f_executable as *mut v3_13_0::PyCodeObject } fn lasti(&self) -> i32 { let co_code = self.f_executable as *const _ as *const u8; unsafe { (self.instr_ptr as *const u8).offset_from(co_code) as i32 } } fn back(&self) -> *mut Self { self.previous } fn is_entry(&self) -> bool { // https://github.com/python/cpython/pull/108036#issuecomment-1684458828 const FRAME_OWNED_BY_CSTACK: ::std::os::raw::c_char = 3; self.owner == FRAME_OWNED_BY_CSTACK } } impl Object for v3_13_0::PyObject { type TypeObject = v3_13_0::PyTypeObject; fn ob_type(&self) -> *mut Self::TypeObject { self.ob_type as *mut Self::TypeObject } } impl TypeObject for v3_13_0::PyTypeObject { fn name(&self) -> *const ::std::os::raw::c_char { self.tp_name } fn dictoffset(&self) -> isize { self.tp_dictoffset } fn flags(&self) -> usize { self.tp_flags as usize } } CompactCodeObjectImpl!(v3_13_0, PyBytesObject, PyUnicodeObject); // Python 3.12 // TODO: this shares some similarities with python 3.11, we should refactor to a common macro Python3Impl!(v3_12_0); impl InterpreterState for v3_12_0::PyInterpreterState { type ThreadState = v3_12_0::PyThreadState; type Object = v3_12_0::PyObject; type StringObject = v3_12_0::PyUnicodeObject; type ListObject = v3_12_0::PyListObject; type TupleObject = v3_12_0::PyTupleObject; const HAS_GIL_RUNTIME_STATE: bool = true; fn threadstate_ptr_ptr(interpreter_address: usize) -> *const *const Self::ThreadState { (interpreter_address + std::mem::offset_of!(Self, threads.head)) as *const *const Self::ThreadState } fn modules_ptr_ptr(interpreter_address: usize) -> *const *const Self::Object { (interpreter_address + std::mem::offset_of!(Self, imports.modules)) as *const *const Self::Object } } impl ThreadState for v3_12_0::PyThreadState { type FrameObject = v3_12_0::_PyInterpreterFrame; type InterpreterState = v3_12_0::PyInterpreterState; fn frame_address(&self) -> Option { // There must be a way to get the offset here without actually creating the object let cframe: v3_12_0::_PyCFrame = Default::default(); let current_frame_offset = offset_of(&cframe, &cframe.current_frame); Some(self.cframe as usize + current_frame_offset) } fn frame(&self, addr: Option) -> *mut Self::FrameObject { addr.unwrap() as *mut Self::FrameObject } fn thread_id(&self) -> u64 { self.thread_id as u64 } fn native_thread_id(&self) -> Option { Some(self.native_thread_id as u64) } fn next(&self) -> *mut Self { self.next } fn interp(&self) -> *mut Self::InterpreterState { self.interp } } impl FrameObject for v3_12_0::_PyInterpreterFrame { type CodeObject = v3_12_0::PyCodeObject; fn code(&self) -> *mut Self::CodeObject { self.f_code } fn lasti(&self) -> i32 { // this returns the delta from the co_code, but we need to adjust for the // offset from co_code.co_code_adaptive. This is slightly easier to do in the // get_line_number code, so will adjust there let co_code = self.f_code as *const _ as *const u8; unsafe { (self.prev_instr as *const u8).offset_from(co_code) as i32 } } fn back(&self) -> *mut Self { self.previous } fn is_entry(&self) -> bool { // https://github.com/python/cpython/pull/108036#issuecomment-1684458828 const FRAME_OWNED_BY_CSTACK: ::std::os::raw::c_char = 3; self.owner == FRAME_OWNED_BY_CSTACK } } impl Object for v3_12_0::PyObject { type TypeObject = v3_12_0::PyTypeObject; fn ob_type(&self) -> *mut Self::TypeObject { self.ob_type as *mut Self::TypeObject } } impl TypeObject for v3_12_0::PyTypeObject { fn name(&self) -> *const ::std::os::raw::c_char { self.tp_name } fn dictoffset(&self) -> isize { self.tp_dictoffset } fn flags(&self) -> usize { self.tp_flags as usize } } CompactCodeObjectImpl!(v3_12_0, PyBytesObject, PyUnicodeObject); // Python 3.11 // Python3.11 is sufficiently different from previous versions that we can't use the macros above // to generate implementations of these traits. Python3Impl!(v3_11_0); impl InterpreterState for v3_11_0::PyInterpreterState { type ThreadState = v3_11_0::PyThreadState; type Object = v3_11_0::PyObject; type StringObject = v3_11_0::PyUnicodeObject; type ListObject = v3_11_0::PyListObject; type TupleObject = v3_11_0::PyTupleObject; fn threadstate_ptr_ptr(interpreter_address: usize) -> *const *const Self::ThreadState { (interpreter_address + std::mem::offset_of!(Self, threads.head)) as *const *const Self::ThreadState } fn modules_ptr_ptr(interpreter_address: usize) -> *const *const Self::Object { (interpreter_address + std::mem::offset_of!(Self, modules)) as *const *const Self::Object } } impl ThreadState for v3_11_0::PyThreadState { type FrameObject = v3_11_0::_PyInterpreterFrame; type InterpreterState = v3_11_0::PyInterpreterState; fn frame_address(&self) -> Option { // There must be a way to get the offset here without actually creating the object let cframe: v3_11_0::_PyCFrame = Default::default(); let current_frame_offset = offset_of(&cframe, &cframe.current_frame); Some(self.cframe as usize + current_frame_offset) } fn frame(&self, addr: Option) -> *mut Self::FrameObject { addr.unwrap() as *mut Self::FrameObject } fn thread_id(&self) -> u64 { self.thread_id as u64 } fn native_thread_id(&self) -> Option { Some(self.native_thread_id as u64) } fn next(&self) -> *mut Self { self.next } fn interp(&self) -> *mut Self::InterpreterState { self.interp } } impl FrameObject for v3_11_0::_PyInterpreterFrame { type CodeObject = v3_11_0::PyCodeObject; fn code(&self) -> *mut Self::CodeObject { self.f_code } fn lasti(&self) -> i32 { // this returns the delta from the co_code, but we need to adjust for the // offset from co_code.co_code_adaptive. This is slightly easier to do in the // get_line_number code, so will adjust there let co_code = self.f_code as *const _ as *const u8; unsafe { (self.prev_instr as *const u8).offset_from(co_code) as i32 } } fn back(&self) -> *mut Self { self.previous } fn is_entry(&self) -> bool { self.is_entry } } impl Object for v3_11_0::PyObject { type TypeObject = v3_11_0::PyTypeObject; fn ob_type(&self) -> *mut Self::TypeObject { self.ob_type as *mut Self::TypeObject } } impl TypeObject for v3_11_0::PyTypeObject { fn name(&self) -> *const ::std::os::raw::c_char { self.tp_name } fn dictoffset(&self) -> isize { self.tp_dictoffset } fn flags(&self) -> usize { self.tp_flags as usize } } CompactCodeObjectImpl!(v3_11_0, PyBytesObject, PyUnicodeObject); // Python 3.10 Python3Impl!(v3_10_0); PythonCommonImpl!(v3_10_0, PyUnicodeObject); impl CodeObject for v3_10_0::PyCodeObject { type BytesObject = v3_10_0::PyBytesObject; type StringObject = v3_10_0::PyUnicodeObject; type TupleObject = v3_10_0::PyTupleObject; fn name(&self) -> *mut Self::StringObject { self.co_name as *mut Self::StringObject } fn filename(&self) -> *mut Self::StringObject { self.co_filename as *mut Self::StringObject } fn line_table(&self) -> *mut Self::BytesObject { self.co_linetable as *mut Self::BytesObject } fn first_lineno(&self) -> i32 { self.co_firstlineno } fn nlocals(&self) -> i32 { self.co_nlocals } fn argcount(&self) -> i32 { self.co_argcount } fn varnames(&self) -> *mut Self::TupleObject { self.co_varnames as *mut Self::TupleObject } fn get_line_number(&self, lasti: i32, table: &[u8]) -> i32 { // in Python 3.10 we need to double the lasti instruction value here (and no I don't know why) // https://github.com/python/cpython/blob/7b88f63e1dd4006b1a08b9c9f087dd13449ecc76/Python/ceval.c#L5999 // Whereas in python versions up to 3.9 we didn't. // https://github.com/python/cpython/blob/3.9/Python/ceval.c#L4713-L4714 let lasti = 2 * lasti as i32; // unpack the line table. format is specified here: // https://github.com/python/cpython/blob/3.10/Objects/lnotab_notes.txt let size = table.len(); let mut i = 0; let mut line_number: i32 = self.first_lineno(); let mut bytecode_address: i32 = 0; while (i + 1) < size { let delta: u8 = table[i]; let line_delta: i8 = table[i + 1] as i8; i += 2; if line_delta == -128 { continue; } line_number += i32::from(line_delta); bytecode_address += i32::from(delta); if bytecode_address > lasti { break; } } line_number } } // Python 3.9 PythonCommonImpl!(v3_9_5, PyUnicodeObject); PythonCodeObjectImpl!(v3_9_5, PyBytesObject, PyUnicodeObject); Python3Impl!(v3_9_5); // Python 3.8 PythonCommonImpl!(v3_8_0, PyUnicodeObject); PythonCodeObjectImpl!(v3_8_0, PyBytesObject, PyUnicodeObject); Python3Impl!(v3_8_0); // Python 3.7 PythonCommonImpl!(v3_7_0, PyUnicodeObject); PythonCodeObjectImpl!(v3_7_0, PyBytesObject, PyUnicodeObject); Python3Impl!(v3_7_0); // Python 3.6 PythonCommonImpl!(v3_6_6, PyUnicodeObject); PythonCodeObjectImpl!(v3_6_6, PyBytesObject, PyUnicodeObject); Python3Impl!(v3_6_6); // python 3.5 and python 3.4 PythonCommonImpl!(v3_5_5, PyUnicodeObject); PythonCodeObjectImpl!(v3_5_5, PyBytesObject, PyUnicodeObject); Python3Impl!(v3_5_5); // python 3.3 PythonCommonImpl!(v3_3_7, PyUnicodeObject); PythonCodeObjectImpl!(v3_3_7, PyBytesObject, PyUnicodeObject); Python3Impl!(v3_3_7); // Python 2.7 PythonCommonImpl!(v2_7_15, PyStringObject); PythonCodeObjectImpl!(v2_7_15, PyStringObject, PyStringObject); impl BytesObject for v2_7_15::PyStringObject { fn size(&self) -> usize { self.ob_size as usize } fn address(&self, base: usize) -> usize { base + offset_of(self, &self.ob_sval) } } impl StringObject for v2_7_15::PyStringObject { fn ascii(&self) -> bool { true } fn kind(&self) -> u32 { 1 } fn size(&self) -> usize { self.ob_size as usize } fn address(&self, base: usize) -> usize { base + offset_of(self, &self.ob_sval) } } impl ListObject for v2_7_15::PyListObject { type Object = v2_7_15::PyObject; fn size(&self) -> usize { self.ob_size as usize } fn item(&self) -> *mut *mut Self::Object { self.ob_item } } impl TupleObject for v2_7_15::PyTupleObject { fn size(&self) -> usize { self.ob_size as usize } fn address(&self, base: usize, index: usize) -> usize { base + offset_of(self, &self.ob_item) + index * std::mem::size_of::<*mut v2_7_15::PyObject>() } } #[cfg(test)] mod tests { use super::*; #[test] fn test_py3_11_line_numbers() { use crate::python_bindings::v3_11_0::PyCodeObject; let code = PyCodeObject { co_firstlineno: 4, ..Default::default() }; let table = [ 128_u8, 0, 221, 4, 8, 132, 74, 136, 118, 209, 4, 22, 212, 4, 22, 208, 4, 22, 208, 4, 22, 208, 4, 22, ]; assert_eq!(code.get_line_number(214, &table), 5); } } ================================================ FILE: src/python_process_info.rs ================================================ use regex::Regex; #[cfg(windows)] use regex::RegexBuilder; #[cfg(windows)] use std::collections::HashMap; use std::mem::size_of; use std::path::Path; use std::slice; use anyhow::{Context, Error, Result}; use lazy_static::lazy_static; use proc_maps::{get_process_maps, MapRange}; #[cfg(not(target_os = "macos"))] use remoteprocess::Pid; use remoteprocess::ProcessMemory; use crate::binary_parser::{parse_binary, BinaryInfo}; use crate::config::Config; use crate::python_bindings::{ pyruntime, v2_7_15, v3_10_0, v3_11_0, v3_12_0, v3_13_0, v3_3_7, v3_5_5, v3_6_6, v3_7_0, v3_8_0, v3_9_5, }; use crate::python_interpreters::{InterpreterState, ThreadState}; use crate::stack_trace::get_stack_traces; use crate::version::Version; /// Holds information about the python process: memory map layout, parsed binary info /// for python /libpython etc. pub struct PythonProcessInfo { pub python_binary: Option, // if python was compiled with './configure --enabled-shared', code/symbols will // be in a libpython.so file instead of the executable. support that. pub libpython_binary: Option, pub maps: Box, pub python_filename: std::path::PathBuf, #[cfg(target_os = "linux")] pub dockerized: bool, } impl PythonProcessInfo { pub fn new(process: &remoteprocess::Process) -> Result { let filename = process .exe() .context("Failed to get process executable name. Check that the process is running.")?; #[cfg(windows)] let filename = filename.to_lowercase(); #[cfg(windows)] let is_python_bin = |pathname: &str| pathname.to_lowercase() == filename; #[cfg(not(windows))] let is_python_bin = |pathname: &str| pathname == filename; // get virtual memory layout let maps = get_process_maps(process.pid)?; info!("Got virtual memory maps from pid {}:", process.pid); for map in &maps { debug!( "map: {:016x}-{:016x} {}{}{} {}", map.start(), map.start() + map.size(), if map.is_read() { 'r' } else { '-' }, if map.is_write() { 'w' } else { '-' }, if map.is_exec() { 'x' } else { '-' }, map.filename() .unwrap_or(&std::path::PathBuf::from("")) .display() ); } // parse the main python binary let (python_binary, python_filename) = { // Get the memory address for the executable by matching against virtual memory maps let map = maps.iter().find(|m| { if let Some(pathname) = m.filename() { if let Some(pathname) = pathname.to_str() { #[cfg(not(windows))] { return is_python_bin(pathname) && m.is_exec(); } #[cfg(windows)] { return is_python_bin(pathname); } } } false }); let map = match map { Some(map) => map, None => { warn!("Failed to find '{}' in virtual memory maps, falling back to first map region", filename); // If we failed to find the executable in the virtual memory maps, just take the first file we find // sometimes on windows get_process_exe returns stale info =( https://github.com/benfred/py-spy/issues/40 // and on all operating systems I've tried, the exe is the first region in the maps maps.first().ok_or_else(|| { format_err!("Failed to get virtual memory maps from process") })? } }; #[cfg(not(target_os = "linux"))] let filename = std::path::PathBuf::from(filename); // use filename through /proc/pid/exe which works across docker namespaces and // handles if the file was deleted #[cfg(target_os = "linux")] let filename = std::path::PathBuf::from(format!("/proc/{}/exe", process.pid)); // TODO: consistent types? u64 -> usize? for map.start etc let python_binary = parse_binary(&filename, map.start() as u64, map.size() as u64); // windows symbols are stored in separate files (.pdb), load #[cfg(windows)] let python_binary = python_binary.and_then(|mut pb| { get_windows_python_symbols(process.pid, &filename, map.start() as u64) .map(|symbols| { pb.symbols.extend(symbols); pb }) .map_err(|err| err.into()) }); // For OSX, need to adjust main binary symbols by subtracting _mh_execute_header // (which we've added to by map.start already, so undo that here) #[cfg(target_os = "macos")] let python_binary = python_binary.map(|mut pb| { let offset = pb.symbols["_mh_execute_header"] - map.start() as u64; for address in pb.symbols.values_mut() { *address -= offset; } if pb.bss_addr != 0 { pb.bss_addr -= offset; } pb }); (python_binary, filename) }; // likewise handle libpython for python versions compiled with --enabled-shared let libpython_binary = { let libmaps: Vec<_> = maps .iter() .filter(|m| { if let Some(pathname) = m.filename() { if let Some(pathname) = pathname.to_str() { #[cfg(not(windows))] { return is_python_lib(pathname) && m.is_exec(); } #[cfg(windows)] { return is_python_lib(pathname); } } } false }) .collect(); let mut libpython_binary: Option = None; #[cfg(not(target_os = "linux"))] let libpython_option = if !libmaps.is_empty() { Some(&libmaps[0]) } else { None }; #[cfg(target_os = "linux")] let libpython_option = libmaps.iter().min_by_key(|m| m.offset); if let Some(libpython) = libpython_option { if let Some(filename) = &libpython.filename() { info!("Found libpython binary @ {}", filename.display()); // on linux the process could be running in docker, access the filename through procfs #[cfg(target_os = "linux")] let filename = &std::path::PathBuf::from(format!( "/proc/{}/root{}", process.pid, filename.display() )); #[allow(unused_mut)] let mut parsed = parse_binary(filename, libpython.start() as u64, libpython.size() as u64)?; #[cfg(windows)] parsed.symbols.extend(get_windows_python_symbols( process.pid, filename, libpython.start() as u64, )?); libpython_binary = Some(parsed); } } // On OSX, it's possible that the Python library is a dylib loaded up from the system // framework (like /System/Library/Frameworks/Python.framework/Versions/2.7/Python) // In this case read in the dyld_info information and figure out the filename from there #[cfg(target_os = "macos")] { if libpython_binary.is_none() { use proc_maps::mac_maps::get_dyld_info; let dyld_infos = get_dyld_info(process.pid)?; for dyld in &dyld_infos { let segname = unsafe { std::ffi::CStr::from_ptr(dyld.segment.segname.as_ptr()) }; debug!( "dyld: {:016x}-{:016x} {:10} {}", dyld.segment.vmaddr, dyld.segment.vmaddr + dyld.segment.vmsize, segname.to_string_lossy(), dyld.filename.display() ); } let python_dyld_data = dyld_infos.iter().find(|m| { if let Some(filename) = m.filename.to_str() { return is_python_framework(filename) && m.segment.segname[0..7] == [95, 95, 68, 65, 84, 65, 0]; } false }); if let Some(libpython) = python_dyld_data { info!( "Found libpython binary from dyld @ {}", libpython.filename.display() ); let mut binary = parse_binary( &libpython.filename, libpython.segment.vmaddr, libpython.segment.vmsize, )?; // TODO: bss addr offsets returned from parsing binary are wrong // (assumes data section isn't split from text section like done here). // BSS occurs somewhere in the data section, just scan that // (could later tighten this up to look at segment sections too) binary.bss_addr = libpython.segment.vmaddr; binary.bss_size = libpython.segment.vmsize; libpython_binary = Some(binary); } } } libpython_binary }; // If we have a libpython binary - we can tolerate failures on parsing the main python binary. let python_binary = match libpython_binary { None => Some(python_binary.context("Failed to parse python binary")?), _ => python_binary.ok(), }; #[cfg(target_os = "linux")] let dockerized = is_dockerized(process.pid).unwrap_or(false); Ok(PythonProcessInfo { python_binary, libpython_binary, maps: Box::new(maps), python_filename, #[cfg(target_os = "linux")] dockerized, }) } pub fn get_symbol(&self, symbol: &str) -> Option<&u64> { if let Some(ref pb) = self.python_binary { if let Some(addr) = pb.symbols.get(symbol) { info!("got symbol {} (0x{:016x}) from python binary", symbol, addr); return Some(addr); } } if let Some(ref binary) = self.libpython_binary { if let Some(addr) = binary.symbols.get(symbol) { info!( "got symbol {} (0x{:016x}) from libpython binary", symbol, addr ); return Some(addr); } } None } } /// Returns the version of python running in the process. pub fn get_python_version

(python_info: &PythonProcessInfo, process: &P) -> Result where P: ProcessMemory, { // If possible, grab the sys.version string from the processes memory (mac osx). if let Some(&addr) = python_info .get_symbol("Py_GetVersion.version") .or_else(|| python_info.get_symbol("version")) { info!("Getting version from symbol address"); if let Ok(bytes) = process.copy(addr as usize, 128) { if let Ok(version) = Version::scan_bytes(&bytes) { return Ok(version); } } } // otherwise get version info from scanning BSS section for sys.version string if let Some(ref pb) = python_info.python_binary { info!("Getting version from python binary BSS"); let bss = process.copy(pb.bss_addr as usize, pb.bss_size as usize)?; match Version::scan_bytes(&bss) { Ok(version) => return Ok(version), Err(err) => info!("Failed to get version from BSS section: {}", err), } } // try again if there is a libpython.so if let Some(ref libpython) = python_info.libpython_binary { info!("Getting version from libpython BSS"); let bss = process.copy(libpython.bss_addr as usize, libpython.bss_size as usize)?; match Version::scan_bytes(&bss) { Ok(version) => return Ok(version), Err(err) => info!("Failed to get version from libpython BSS section: {}", err), } } // the python_filename might have the version encoded in it (/usr/bin/python3.5 etc). // try reading that in (will miss patch level on python, but that shouldn't matter) info!( "Trying to get version from path: {}", python_info.python_filename.display() ); let path = Path::new(&python_info.python_filename); if let Some(python) = path.file_name() { if let Some(python) = python.to_str() { if let Some(stripped_python) = python.strip_prefix("python") { let tokens: Vec<&str> = stripped_python.split('.').collect(); if tokens.len() >= 2 { if let (Ok(major), Ok(minor)) = (tokens[0].parse::(), tokens[1].parse::()) { return Ok(Version { major, minor, patch: 0, release_flags: "".to_owned(), build_metadata: None, }); } } } } } Err(format_err!( "Failed to find python version from target process" )) } pub fn get_interpreter_address

( python_info: &PythonProcessInfo, process: &P, version: &Version, ) -> Result where P: ProcessMemory, { // get the address of the main PyInterpreterState object from loaded symbols if we can // (this tends to be faster than scanning through the bss section) match version { Version { major: 3, minor: 13, .. } => { if let Some(&addr) = python_info.get_symbol("_PyRuntime") { // figure out the interpreters_head location using the debug_offsets let debug_offsets: v3_13_0::_Py_DebugOffsets = process.copy_struct(addr as usize)?; let addr = process.copy_struct( addr as usize + debug_offsets.runtime_state.interpreters_head as usize, )?; // Make sure the interpreter addr is valid before returning match check_interpreter_addresses(&[addr], &*python_info.maps, process, version) { Ok(addr) => return Ok(addr), Err(_) => { warn!( "Interpreter address from _PyRuntime symbol is invalid {:016x}", addr ); } }; } } Version { major: 3, minor: 7..=12, .. } => { if let Some(&addr) = python_info.get_symbol("_PyRuntime") { let addr = process .copy_struct(addr as usize + pyruntime::get_interp_head_offset(version))?; // Make sure the interpreter addr is valid before returning match check_interpreter_addresses(&[addr], &*python_info.maps, process, version) { Ok(addr) => return Ok(addr), Err(_) => { warn!( "Interpreter address from _PyRuntime symbol is invalid {:016x}", addr ); } }; } } _ => { if let Some(&addr) = python_info.get_symbol("interp_head") { let addr = process.copy_struct(addr as usize)?; match check_interpreter_addresses(&[addr], &*python_info.maps, process, version) { Ok(addr) => return Ok(addr), Err(_) => { warn!( "Interpreter address from interp_head symbol is invalid {:016x}", addr ); } }; } } }; info!("Failed to find runtime address from symbols, scanning BSS section from main binary"); // try scanning the BSS section of the binary for things that might be the interpreterstate let err = if let Some(ref pb) = python_info.python_binary { match get_interpreter_address_from_binary(pb, &*python_info.maps, process, version) { Ok(addr) => return Ok(addr), err => Some(err), } } else { None }; // Before giving up, try again if there is a libpython.so if let Some(ref lpb) = python_info.libpython_binary { info!("Failed to get interpreter from binary BSS, scanning libpython BSS"); match get_interpreter_address_from_binary(lpb, &*python_info.maps, process, version) { Ok(addr) => Ok(addr), lib_err => err.unwrap_or(lib_err), } } else { err.expect("Both python and libpython are invalid.") } } fn get_interpreter_address_from_binary

( binary: &BinaryInfo, maps: &dyn ContainsAddr, process: &P, version: &Version, ) -> Result where P: ProcessMemory, { // First check the pyruntime section it was found if binary.pyruntime_addr != 0 { let bss = process.copy( binary.pyruntime_addr as usize, binary.pyruntime_size as usize, )?; #[allow(clippy::cast_ptr_alignment)] let addrs = unsafe { slice::from_raw_parts(bss.as_ptr() as *const usize, bss.len() / size_of::()) }; if let Ok(addr) = check_interpreter_addresses(addrs, maps, process, version) { return Ok(addr); } } // We're going to scan the BSS/data section for things, and try to narrowly scan things that // look like pointers to PyinterpreterState let bss = process.copy(binary.bss_addr as usize, binary.bss_size as usize)?; #[allow(clippy::cast_ptr_alignment)] let addrs = unsafe { slice::from_raw_parts(bss.as_ptr() as *const usize, bss.len() / size_of::()) }; check_interpreter_addresses(addrs, maps, process, version) } // Checks whether a block of memory (from BSS/.data etc) contains pointers that are pointing // to a valid PyInterpreterState fn check_interpreter_addresses

( addrs: &[usize], maps: &dyn ContainsAddr, process: &P, version: &Version, ) -> Result where P: ProcessMemory, { // This function does all the work, but needs a type of the interpreter fn check(addrs: &[usize], maps: &dyn ContainsAddr, process: &P) -> Result where I: InterpreterState, P: ProcessMemory, { for &addr in addrs { if maps.contains_addr(addr) { // get the pythreadstate pointer from the interpreter object, and if it is also // a valid pointer then load it up. let threadstate_ptr_ptr = I::threadstate_ptr_ptr(addr); let maybe_threads = process .copy_struct(threadstate_ptr_ptr as usize) .context("Failed to copy PyThreadState head pointer"); let threads: *const I::ThreadState = match maybe_threads { Ok(threads) => threads, Err(_) => continue, }; if maps.contains_addr(threads as usize) { // If the threadstate points back to the interpreter like we expect, then // this is almost certainly the address of the intrepreter let thread = match process.copy_pointer(threads) { Ok(thread) => thread, Err(_) => continue, }; // as a final sanity check, try getting the stack_traces, and only return if this works if thread.interp() as usize == addr && get_stack_traces::(addr, process, 0, None).is_ok() { return Ok(addr); } } } } Err(format_err!( "Failed to find a python interpreter in the .data section" )) } // different versions have different layouts, check as appropriate match version { Version { major: 2, minor: 3..=7, .. } => check::(addrs, maps, process), Version { major: 3, minor: 3, .. } => check::(addrs, maps, process), Version { major: 3, minor: 4..=5, .. } => check::(addrs, maps, process), Version { major: 3, minor: 6, .. } => check::(addrs, maps, process), Version { major: 3, minor: 7, .. } => check::(addrs, maps, process), Version { major: 3, minor: 8, patch: 0, .. } => match version.release_flags.as_ref() { "a1" | "a2" | "a3" => check::(addrs, maps, process), _ => check::(addrs, maps, process), }, Version { major: 3, minor: 8, .. } => check::(addrs, maps, process), Version { major: 3, minor: 9, .. } => check::(addrs, maps, process), Version { major: 3, minor: 10, .. } => check::(addrs, maps, process), Version { major: 3, minor: 11, .. } => check::(addrs, maps, process), Version { major: 3, minor: 12, .. } => check::(addrs, maps, process), Version { major: 3, minor: 13, .. } => check::(addrs, maps, process), _ => Err(format_err!("Unsupported version of Python: {}", version)), } } pub fn get_threadstate_address

( interpreter_address: usize, python_info: &PythonProcessInfo, process: &P, version: &Version, config: &Config, ) -> Result where P: ProcessMemory, { let threadstate_address = match version { Version { major: 3, minor: 13, .. } => { let gil_ptr = interpreter_address + std::mem::offset_of!(v3_13_0::_is, ceval.gil); process.copy_struct::(gil_ptr)? } Version { major: 3, minor: 12, .. } => { let gil_ptr = interpreter_address + std::mem::offset_of!(v3_12_0::_is, ceval.gil); let gil: usize = process.copy_struct(gil_ptr)?; gil } Version { major: 3, minor: 7..=11, .. } => match python_info.get_symbol("_PyRuntime") { Some(&addr) => { if let Some(offset) = pyruntime::get_tstate_current_offset(version) { info!("Found _PyRuntime @ 0x{:016x}, getting gilstate.tstate_current from offset 0x{:x}", addr, offset); addr as usize + offset } else { error_if_gil( config, version, "unknown pyruntime.gilstate.tstate_current offset", )?; 0 } } None => { error_if_gil(config, version, "failed to find _PyRuntime symbol")?; 0 } }, _ => match python_info.get_symbol("_PyThreadState_Current") { Some(&addr) => { info!("Found _PyThreadState_Current @ 0x{:016x}", addr); addr as usize } None => { error_if_gil( config, version, "failed to find _PyThreadState_Current symbol", )?; 0 } }, }; Ok(threadstate_address) } fn error_if_gil(config: &Config, version: &Version, msg: &str) -> Result<(), Error> { lazy_static! { static ref WARNED: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false); } if config.gil_only { if !WARNED.load(std::sync::atomic::Ordering::Relaxed) { // only print this once eprintln!( "Cannot detect GIL holding in version '{version}' on the current platform (reason: {msg})" ); eprintln!("Please open an issue in https://github.com/benfred/py-spy with the Python version and your platform."); WARNED.store(true, std::sync::atomic::Ordering::Relaxed); } Err(format_err!( "Cannot detect GIL holding in version '{}' on the current platform (reason: {})", version, msg )) } else { warn!("Unable to detect GIL usage: {}", msg); Ok(()) } } pub trait ContainsAddr { fn contains_addr(&self, addr: usize) -> bool; } impl ContainsAddr for Vec { #[cfg(windows)] fn contains_addr(&self, _addr: usize) -> bool { // On windows, we can't just check if a pointer is valid by looking to see if it points // to something in the virtual memory map. Brute-force it instead true } #[cfg(not(windows))] fn contains_addr(&self, addr: usize) -> bool { proc_maps::maps_contain_addr(addr, self) } } #[cfg(target_os = "linux")] fn is_dockerized(pid: Pid) -> Result { let self_mnt = std::fs::read_link("/proc/self/ns/mnt")?; let target_mnt = std::fs::read_link(format!("/proc/{}/ns/mnt", pid))?; Ok(self_mnt != target_mnt) } // We can't use goblin to parse external symbol files (like in a separate .pdb file) on windows, // So use the win32 api to load up the couple of symbols we need on windows. Note: // we still can get export's from the PE file #[cfg(windows)] pub fn get_windows_python_symbols( pid: Pid, filename: &Path, offset: u64, ) -> std::io::Result> { use proc_maps::win_maps::SymbolLoader; let handler = SymbolLoader::new(pid)?; let _module = handler.load_module(filename)?; // need to keep this module in scope let mut ret = HashMap::new(); // currently we only need a subset of symbols, and enumerating the symbols is // expensive (via SymEnumSymbolsW), so rather than load up all symbols like we // do for goblin, just load the the couple we need directly. for symbol in ["_PyThreadState_Current", "interp_head", "_PyRuntime"].iter() { if let Ok((base, addr)) = handler.address_from_name(symbol) { // If we have a module base (ie from PDB), need to adjust by the offset // otherwise seems like we can take address directly let addr = if base == 0 { addr } else { offset + addr - base }; ret.insert(String::from(*symbol), addr); } } Ok(ret) } #[cfg(any(target_os = "linux", target_os = "freebsd"))] pub fn is_python_lib(pathname: &str) -> bool { lazy_static! { static ref RE: Regex = Regex::new(r"/libpython\d.\d\d?(m|d|u)?.so").unwrap(); } RE.is_match(pathname) } #[cfg(target_os = "macos")] pub fn is_python_lib(pathname: &str) -> bool { lazy_static! { static ref RE: Regex = Regex::new(r"/libpython\d.\d\d?(m|d|u)?.(dylib|so)$").unwrap(); } RE.is_match(pathname) || is_python_framework(pathname) } #[cfg(windows)] pub fn is_python_lib(pathname: &str) -> bool { lazy_static! { static ref RE: Regex = RegexBuilder::new(r"\\python\d\d\d?(m|d|u)?.dll$") .case_insensitive(true) .build() .unwrap(); } RE.is_match(pathname) } #[cfg(target_os = "macos")] pub fn is_python_framework(pathname: &str) -> bool { pathname.ends_with("/Python") && !pathname.contains("Python.app") } #[cfg(test)] mod tests { use super::*; #[cfg(target_os = "macos")] #[test] fn test_is_python_lib() { assert!(is_python_lib("~/Anaconda2/lib/libpython2.7.dylib")); // python lib configured with --with-pydebug (flag: d) assert!(is_python_lib("/lib/libpython3.4d.dylib")); // configured --with-pymalloc (flag: m) assert!(is_python_lib("/usr/local/lib/libpython3.8m.dylib")); // python2 configured with --with-wide-unicode (flag: u) assert!(is_python_lib("./libpython2.7u.dylib")); assert!(!is_python_lib("/libboost_python.dylib")); assert!(!is_python_lib("/lib/heapq.cpython-36m-darwin.dylib")); } #[cfg(any(target_os = "linux", target_os = "freebsd"))] #[test] fn test_is_python_lib() { // libpython bundled by pyinstaller https://github.com/benfred/py-spy/issues/42 assert!(is_python_lib("/tmp/_MEIOqzg01/libpython2.7.so.1.0")); // test debug/malloc/unicode flags assert!(is_python_lib("./libpython2.7.so")); assert!(is_python_lib("/usr/lib/libpython3.4d.so")); assert!(is_python_lib("/usr/local/lib/libpython3.8m.so")); assert!(is_python_lib("/usr/lib/libpython2.7u.so")); // don't blindly match libraries with python in the name (boost_python etc) assert!(!is_python_lib("/usr/lib/libboost_python.so")); assert!(!is_python_lib( "/usr/lib/x86_64-linux-gnu/libboost_python-py27.so.1.58.0" )); assert!(!is_python_lib("/usr/lib/libboost_python-py35.so")); } #[cfg(windows)] #[test] fn test_is_python_lib() { assert!(is_python_lib( "C:\\Users\\test\\AppData\\Local\\Programs\\Python\\Python37\\python37.dll" )); // .NET host via https://github.com/pythonnet/pythonnet assert!(is_python_lib( "C:\\Users\\test\\AppData\\Local\\Programs\\Python\\Python37\\python37.DLL" )); } #[cfg(target_os = "macos")] #[test] fn test_python_frameworks() { // homebrew v2 assert!(!is_python_framework("/usr/local/Cellar/python@2/2.7.15_1/Frameworks/Python.framework/Versions/2.7/Resources/Python.app/Contents/MacOS/Python")); assert!(is_python_framework( "/usr/local/Cellar/python@2/2.7.15_1/Frameworks/Python.framework/Versions/2.7/Python" )); // System python from osx 10.13.6 (high sierra) assert!(!is_python_framework("/System/Library/Frameworks/Python.framework/Versions/2.7/Resources/Python.app/Contents/MacOS/Python")); assert!(is_python_framework( "/System/Library/Frameworks/Python.framework/Versions/2.7/Python" )); // pyenv 3.6.6 with OSX framework enabled (https://github.com/benfred/py-spy/issues/15) // env PYTHON_CONFIGURE_OPTS="--enable-framework" pyenv install 3.6.6 assert!(is_python_framework( "/Users/ben/.pyenv/versions/3.6.6/Python.framework/Versions/3.6/Python" )); assert!(!is_python_framework("/Users/ben/.pyenv/versions/3.6.6/Python.framework/Versions/3.6/Resources/Python.app/Contents/MacOS/Python")); // single file pyinstaller assert!(is_python_framework( "/private/var/folders/3x/qy479lpd1fb2q88lc9g4d3kr0000gn/T/_MEI2Akvi8/Python" )); } } ================================================ FILE: src/python_spy.rs ================================================ use std::collections::HashMap; #[cfg(all(target_os = "linux", feature = "unwind"))] use std::collections::HashSet; #[cfg(all(target_os = "linux", feature = "unwind"))] use std::iter::FromIterator; use std::path::Path; use anyhow::{Context, Error, Result}; use remoteprocess::{Pid, Process, ProcessMemory, Tid}; use crate::config::{Config, LockingStrategy}; #[cfg(feature = "unwind")] use crate::native_stack_trace::NativeStack; use crate::python_bindings::{ v2_7_15, v3_10_0, v3_11_0, v3_12_0, v3_13_0, v3_3_7, v3_5_5, v3_6_6, v3_7_0, v3_8_0, v3_9_5, }; use crate::python_data_access::format_variable; use crate::python_interpreters::{InterpreterState, ThreadState}; use crate::python_process_info::{ get_interpreter_address, get_python_version, get_threadstate_address, PythonProcessInfo, }; use crate::python_threading::thread_name_lookup; use crate::stack_trace::{get_gil_threadid, get_stack_trace, StackTrace}; use crate::version::Version; /// Lets you retrieve stack traces of a running python program pub struct PythonSpy { pub pid: Pid, pub process: Process, pub version: Version, pub interpreter_address: usize, pub threadstate_address: usize, pub config: Config, #[cfg(feature = "unwind")] pub native: Option, pub short_filenames: HashMap>, pub python_thread_ids: HashMap, pub python_thread_names: HashMap, #[cfg(target_os = "linux")] pub dockerized: bool, } impl PythonSpy { /// Constructs a new PythonSpy object. pub fn new(pid: Pid, config: &Config) -> Result { let process = remoteprocess::Process::new(pid) .context("Failed to open process - check if it is running.")?; // get basic process information (memory maps/symbols etc) let python_info = PythonProcessInfo::new(&process)?; // lock the process when loading up on freebsd (rather than locking // on every memory read). Needs done after getting python process info // because procmaps also tries to attach w/ ptrace on freebsd #[cfg(target_os = "freebsd")] let _lock = process.lock(); let version = get_python_version(&python_info, &process)?; info!("python version {} detected", version); let interpreter_address = get_interpreter_address(&python_info, &process, &version)?; info!("Found interpreter at 0x{:016x}", interpreter_address); // lets us figure out which thread has the GIL let threadstate_address = get_threadstate_address( interpreter_address, &python_info, &process, &version, config, )?; #[cfg(feature = "unwind")] let native = if config.native { Some(NativeStack::new( pid, python_info.python_binary, python_info.libpython_binary, )?) } else { None }; Ok(PythonSpy { pid, process, version, interpreter_address, threadstate_address, #[cfg(feature = "unwind")] native, #[cfg(target_os = "linux")] dockerized: python_info.dockerized, config: config.clone(), short_filenames: HashMap::new(), python_thread_ids: HashMap::new(), python_thread_names: HashMap::new(), }) } /// Creates a PythonSpy object, retrying up to max_retries times. /// Mainly useful for the case where the process is just started and /// symbols or the python interpreter might not be loaded yet. pub fn retry_new(pid: Pid, config: &Config, max_retries: u64) -> Result { let mut retries = 0; loop { let err = match PythonSpy::new(pid, config) { Ok(mut process) => { // verify that we can load a stack trace before returning success match process.get_stack_traces() { Ok(_) => return Ok(process), Err(err) => err, } } Err(err) => err, }; // If we failed, retry a couple times before returning the last error retries += 1; if retries >= max_retries { return Err(err); } info!("Failed to connect to process, retrying. Error: {}", err); std::thread::sleep(std::time::Duration::from_millis(20)); } } /// Gets a StackTrace for each thread in the current process pub fn get_stack_traces(&mut self) -> Result, Error> { match self.version { // ABI for 2.3/2.4/2.5/2.6/2.7 is compatible for our purpose Version { major: 2, minor: 3..=7, .. } => self._get_stack_traces::(), Version { major: 3, minor: 3, .. } => self._get_stack_traces::(), // ABI for 3.4 and 3.5 is the same for our purposes Version { major: 3, minor: 4, .. } => self._get_stack_traces::(), Version { major: 3, minor: 5, .. } => self._get_stack_traces::(), Version { major: 3, minor: 6, .. } => self._get_stack_traces::(), Version { major: 3, minor: 7, .. } => self._get_stack_traces::(), // v3.8.0a1 to v3.8.0a3 is compatible with 3.7 ABI, but later versions of 3.8.0 aren't Version { major: 3, minor: 8, patch: 0, .. } => match self.version.release_flags.as_ref() { "a1" | "a2" | "a3" => self._get_stack_traces::(), _ => self._get_stack_traces::(), }, Version { major: 3, minor: 8, .. } => self._get_stack_traces::(), Version { major: 3, minor: 9, .. } => self._get_stack_traces::(), Version { major: 3, minor: 10, .. } => self._get_stack_traces::(), Version { major: 3, minor: 11, .. } => self._get_stack_traces::(), Version { major: 3, minor: 12, .. } => self._get_stack_traces::(), Version { major: 3, minor: 13, .. } => self._get_stack_traces::(), _ => Err(format_err!( "Unsupported version of Python: {}", self.version )), } } // implementation of get_stack_traces, where we have a type for the InterpreterState fn _get_stack_traces(&mut self) -> Result, Error> { // Query the OS to get if each thread in the process is running or not let mut thread_activity = HashMap::new(); if self.config.gil_only { // Don't need to collect thread activity if we're only getting the // GIL thread: If we're holding the GIL we're by definition active. } else { for thread in self.process.threads()?.iter() { let threadid: Tid = thread.id()?; let Ok(active) = thread.active() else { // Do not fail all sampling if a single thread died between entering the loop // and reading its status. continue; }; thread_activity.insert(threadid, active); } } // Lock the process if appropriate. Note we have to lock AFTER getting the thread // activity status from the OS (otherwise each thread would report being inactive always). // This has the potential for race conditions (in that the thread activity could change // between getting the status and locking the thread, but seems unavoidable right now let _lock = if self.config.blocking == LockingStrategy::Lock { Some(self.process.lock().context("Failed to suspend process")?) } else { None }; // Find PyThreadState, and loop over all the python threads let threadstate_ptr_ptr = I::threadstate_ptr_ptr(self.interpreter_address); let threads_head = self .process .copy_pointer(threadstate_ptr_ptr) .context("Failed to copy PyThreadState head pointer")?; // get the threadid of the gil if appropriate let gil_thread_id = get_gil_threadid::(self.threadstate_address, &self.process) .context("failed to get gil_thread_id")?; let mut traces = Vec::new(); let mut threads = threads_head; while !threads.is_null() { // Get the stack trace of the python thread let thread = self .process .copy_pointer(threads) .context("Failed to copy PyThreadState")?; threads = thread.next(); let python_thread_id = thread.thread_id(); let owns_gil = python_thread_id == gil_thread_id; if self.config.gil_only && !owns_gil { continue; } let mut trace = get_stack_trace( &thread, &self.process, self.config.dump_locals > 0, self.config.lineno, )?; // Try getting the native thread id // python 3.11+ has the native thread id directly on the PyThreadState object, // for older versions of python, try using OS specific code to get the native // thread id (doesn't work on freebsd, or on arm/i686 processors on linux) if trace.os_thread_id.is_none() { let mut os_thread_id = self._get_os_thread_id::(python_thread_id, threads_head)?; // linux can see issues where pthread_ids get recycled for new OS threads, // which totally breaks the caching we were doing here. Detect this and retry if let Some(tid) = os_thread_id { if !thread_activity.is_empty() && !thread_activity.contains_key(&tid) { info!("clearing away thread id caches, thread {} has exited", tid); self.python_thread_ids.clear(); self.python_thread_names.clear(); os_thread_id = self._get_os_thread_id::(python_thread_id, threads_head)?; } } trace.os_thread_id = os_thread_id.map(|id| id as u64); } trace.thread_name = self._get_python_thread_name(python_thread_id); trace.owns_gil = owns_gil; trace.pid = self.process.pid; // Figure out if the thread is sleeping from the OS if possible trace.active = true; if let Some(id) = trace.os_thread_id { let id = id as Tid; if let Some(active) = thread_activity.get(&id as _) { trace.active = *active; } } // fallback to using a heuristic if we think the thread is still active // Note that on linux the OS thread activity can only be gotten on x86_64 // processors and even then seems to be wrong occasionally in thinking 'select' // calls are active (which seems related to the thread locking code, // this problem doesn't seem to happen with the --nonblocking option) // Note: this should be done before the native merging for correct results if trace.active { trace.active = !self._heuristic_is_thread_idle(&trace); } // Merge in the native stack frames if necessary #[cfg(feature = "unwind")] { if self.config.native { if let Some(native) = self.native.as_mut() { let thread_id = trace .os_thread_id .ok_or_else(|| format_err!("failed to get os threadid"))?; let os_thread = remoteprocess::Thread::new(thread_id as Tid)?; trace.frames = native.merge_native_thread(&trace.frames, &os_thread)? } } } for frame in &mut trace.frames { frame.short_filename = self.shorten_filename(&frame.filename); if let Some(locals) = frame.locals.as_mut() { let max_length = (128 * self.config.dump_locals) as isize; for local in locals { let repr = format_variable::( &self.process, &self.version, local.addr, max_length, ); local.repr = Some(repr.unwrap_or_else(|_| "?".to_owned())); } } } traces.push(trace); // This seems to happen occasionally when scanning BSS addresses for valid interpreters if traces.len() > 4096 { return Err(format_err!("Max thread recursion depth reached")); } if self.config.gil_only { // There's only one GIL thread and we've captured it, so we can // stop now break; } } Ok(traces) } // heuristic fallback for determining if a thread is active, used // when we don't have the ability to get the thread information from the OS fn _heuristic_is_thread_idle(&self, trace: &StackTrace) -> bool { let frames = &trace.frames; if frames.is_empty() { // we could have 0 python frames, but still be active running native // code. false } else { let frame = &frames[0]; (frame.name == "wait" && frame.filename.ends_with("threading.py")) || (frame.name == "select" && frame.filename.ends_with("selectors.py")) || (frame.name == "poll" && (frame.filename.ends_with("asyncore.py") || frame.filename.contains("zmq") || frame.filename.contains("gevent") || frame.filename.contains("tornado"))) } } #[cfg(windows)] fn _get_os_thread_id( &mut self, python_thread_id: u64, _interp_head: *const I::ThreadState, ) -> Result, Error> { Ok(Some(python_thread_id as Tid)) } #[cfg(target_os = "macos")] fn _get_os_thread_id( &mut self, python_thread_id: u64, _interp_head: *const I::ThreadState, ) -> Result, Error> { // If we've already know this threadid, we're good if let Some(thread_id) = self.python_thread_ids.get(&python_thread_id) { return Ok(Some(*thread_id)); } for thread in self.process.threads()?.iter() { // ok, this is crazy pants. is this 224 constant right? Is this right for all versions of OSX? how is this determined? // is this correct for all versions of python? Why does this even work? let current_handle = thread.thread_handle()? - 224; self.python_thread_ids.insert(current_handle, thread.id()?); } if let Some(thread_id) = self.python_thread_ids.get(&python_thread_id) { return Ok(Some(*thread_id)); } Ok(None) } #[cfg(all(target_os = "linux", not(feature = "unwind")))] fn _get_os_thread_id( &mut self, _python_thread_id: u64, _interp_head: *const I::ThreadState, ) -> Result, Error> { Ok(None) } #[cfg(all(target_os = "linux", feature = "unwind"))] fn _get_os_thread_id( &mut self, python_thread_id: u64, interp_head: *const I::ThreadState, ) -> Result, Error> { // in nonblocking mode, we can't get the threadid reliably (method here requires reading the RBX // register which requires a ptrace attach). fallback to heuristic thread activity here if self.config.blocking == LockingStrategy::NonBlocking { return Ok(None); } // likewise this doesn't yet work for profiling processes running inside docker containers from the host os if self.dockerized { return Ok(None); } // If we've already know this threadid, we're good if let Some(thread_id) = self.python_thread_ids.get(&python_thread_id) { return Ok(Some(*thread_id)); } // Get a list of all the python thread ids let mut all_python_threads = HashSet::new(); let mut threads = interp_head; while !threads.is_null() { let thread = self .process .copy_pointer(threads) .context("Failed to copy PyThreadState")?; let current = thread.thread_id(); all_python_threads.insert(current); threads = thread.next(); } let processed_os_threads: HashSet = HashSet::from_iter(self.python_thread_ids.values().copied()); let unwinder = self.process.unwinder()?; // Try getting the pthread_id from the native stack registers for threads we haven't looked up yet for thread in self.process.threads()?.iter() { let threadid = thread.id()?; if processed_os_threads.contains(&threadid) { continue; } match self._get_pthread_id(&unwinder, thread, &all_python_threads) { Ok(pthread_id) => { if pthread_id != 0 { self.python_thread_ids.insert(pthread_id, threadid); } } Err(e) => { warn!("Failed to get get_pthread_id for {}: {}", threadid, e); } }; } // we can't get the python threadid for the main thread from registers, // so instead assign the main threadid (pid) to the missing python thread if !processed_os_threads.contains(&self.pid) { let mut unknown_python_threadids = HashSet::new(); for python_thread_id in all_python_threads.iter() { if !self.python_thread_ids.contains_key(python_thread_id) { unknown_python_threadids.insert(*python_thread_id); } } if unknown_python_threadids.len() == 1 { let python_thread_id = *unknown_python_threadids.iter().next().unwrap(); self.python_thread_ids.insert(python_thread_id, self.pid); } else { warn!("failed to get python threadid for main thread!"); } } if let Some(thread_id) = self.python_thread_ids.get(&python_thread_id) { return Ok(Some(*thread_id)); } info!("failed looking up python threadid for {}. known python_thread_ids {:?}. all_python_threads {:?}", python_thread_id, self.python_thread_ids, all_python_threads); Ok(None) } #[cfg(all(target_os = "linux", feature = "unwind"))] pub fn _get_pthread_id( &self, unwinder: &remoteprocess::Unwinder, thread: &remoteprocess::Thread, threadids: &HashSet, ) -> Result { let mut pthread_id = 0; let mut cursor = unwinder.cursor(thread)?; while let Some(_) = cursor.next() { // the pthread_id is usually a register (rbx on x86-64, r5 on ARM) in the top-level // frame of the thread, but on some configs can be 2nd level. Handle this by taking the // top-most value that is one of the pthread_ids we're looking for #[cfg(target_arch = "x86_64")] let possible_threadid = cursor.bx(); #[cfg(target_arch = "arm")] let possible_threadid = cursor.r5(); if let Ok(reg) = possible_threadid { if reg != 0 && threadids.contains(®) { pthread_id = reg; } } } Ok(pthread_id) } #[cfg(target_os = "freebsd")] fn _get_os_thread_id( &mut self, _python_thread_id: u64, _interp_head: *const I::ThreadState, ) -> Result, Error> { Ok(None) } fn _get_python_thread_name(&mut self, python_thread_id: u64) -> Option { match self.python_thread_names.get(&python_thread_id) { Some(thread_name) => Some(thread_name.clone()), None => { self.python_thread_names = thread_name_lookup(self).unwrap_or_default(); self.python_thread_names.get(&python_thread_id).cloned() } } } /// We want to display filenames without the boilerplate of the python installation /// directory etc. This function looks only includes paths inside a python /// package or subpackage, and not the path the package is installed at fn shorten_filename(&mut self, filename: &str) -> Option { // if the user requested full filenames, skip shortening if self.config.full_filenames { return Some(filename.to_string()); } // if we have figured out the short filename already, use it if let Some(short) = self.short_filenames.get(filename) { return short.clone(); } // on linux the process could be running in docker, access the filename through procfs #[cfg(target_os = "linux")] let filename_storage; #[cfg(target_os = "linux")] let filename = if self.dockerized { filename_storage = format!("/proc/{}/root{}", self.pid, filename); if Path::new(&filename_storage).exists() { &filename_storage } else { filename } } else { filename }; // only include paths that include an __init__.py let mut path = Path::new(filename); while let Some(parent) = path.parent() { path = parent; if !parent.join("__init__.py").exists() { break; } } // remove the parent prefix and convert to an optional string let shortened = Path::new(filename) .strip_prefix(path) .ok() .map(|p| p.to_string_lossy().to_string()); self.short_filenames .insert(filename.to_owned(), shortened.clone()); shortened } } ================================================ FILE: src/python_threading.rs ================================================ use std::collections::HashMap; use anyhow::{Context, Error}; use crate::python_bindings::{v3_10_0, v3_11_0, v3_12_0, v3_13_0, v3_6_6, v3_7_0, v3_8_0, v3_9_5}; use crate::python_data_access::{copy_long, copy_string, DictIterator, PY_TPFLAGS_MANAGED_DICT}; use crate::python_interpreters::{InterpreterState, Object, TypeObject}; use crate::python_spy::PythonSpy; use remoteprocess::Process; use crate::version::Version; use remoteprocess::ProcessMemory; /// Returns a hashmap of threadid: threadname, by inspecting the '_active' variable in the /// 'threading' module. pub fn thread_names_from_interpreter( interpreter_address: usize, process: &P, version: &Version, ) -> Result, Error> { let modules_ptr_ptr = I::modules_ptr_ptr(interpreter_address); let modules: *const I::Object = process .copy_pointer(modules_ptr_ptr) .context("Failed to copy modules PyObject")?; let mut ret = HashMap::new(); for entry in DictIterator::from(process, version, modules as usize)? { let (key, value) = entry?; let module_name = copy_string(key as *const I::StringObject, process)?; if module_name == "threading" { let module: I::Object = process.copy_struct(value)?; let module_type = process.copy_pointer(module.ob_type())?; let dictptr: usize = process.copy_struct(value + module_type.dictoffset() as usize)?; for i in DictIterator::from(process, version, dictptr)? { let (key, value) = i?; let name = copy_string(key as *const I::StringObject, process)?; if name == "_active" { for i in DictIterator::from(process, version, value)? { let (key, value) = i?; let (threadid, _) = copy_long(process, version, key)?; let thread: I::Object = process.copy_struct(value)?; let thread_type = process.copy_pointer(thread.ob_type())?; let flags = thread_type.flags(); let dict_iter = if flags & PY_TPFLAGS_MANAGED_DICT != 0 { DictIterator::from_managed_dict( process, version, value, thread.ob_type() as usize, flags, )? } else { let dict_offset = thread_type.dictoffset(); let dict_addr = (value as isize + dict_offset) as usize; let thread_dict_addr: usize = process.copy_struct(dict_addr)?; DictIterator::from(process, version, thread_dict_addr)? }; for i in dict_iter { let (key, value) = i?; let varname = copy_string(key as *const I::StringObject, process)?; if varname == "_name" { let threadname = copy_string(value as *const I::StringObject, process)?; ret.insert(threadid as u64, threadname); break; } } } break; } } break; } } Ok(ret) } /// Returns a hashmap of threadid: threadname, by inspecting the '_active' variable in the /// 'threading' module. fn _thread_name_lookup( spy: &PythonSpy, ) -> Result, Error> { thread_names_from_interpreter::(spy.interpreter_address, &spy.process, &spy.version) } // try getting the threadnames, but don't sweat it if we can't. Since this relies on dictionary // processing we only handle py3.6+ right now, and this doesn't work at all if the // threading module isn't imported in the target program pub fn thread_name_lookup(process: &PythonSpy) -> Option> { let err = match process.version { Version { major: 3, minor: 6, .. } => _thread_name_lookup::(process), Version { major: 3, minor: 7, .. } => _thread_name_lookup::(process), Version { major: 3, minor: 8, .. } => _thread_name_lookup::(process), Version { major: 3, minor: 9, .. } => _thread_name_lookup::(process), Version { major: 3, minor: 10, .. } => _thread_name_lookup::(process), Version { major: 3, minor: 11, .. } => _thread_name_lookup::(process), Version { major: 3, minor: 12, .. } => _thread_name_lookup::(process), Version { major: 3, minor: 13, .. } => _thread_name_lookup::(process), _ => return None, }; err.ok() } ================================================ FILE: src/sampler.rs ================================================ #![allow(clippy::type_complexity)] use std::collections::HashMap; use std::sync::mpsc::{self, Receiver, Sender}; use std::sync::{Arc, Mutex}; use std::thread; use std::time::Duration; use anyhow::Error; use remoteprocess::Pid; use crate::config::Config; use crate::python_spy::PythonSpy; use crate::stack_trace::{ProcessInfo, StackTrace}; use crate::timer::Timer; use crate::version::Version; pub struct Sampler { pub version: Option, rx: Option>, sampling_thread: Option>, } pub struct Sample { pub traces: Vec, pub sampling_errors: Option>, pub late: Option, } impl Sampler { pub fn new(pid: Pid, config: &Config) -> Result { if config.subprocesses { Self::new_subprocess_sampler(pid, config) } else { Self::new_sampler(pid, config) } } /// Creates a new sampler object, reading from a single process only fn new_sampler(pid: Pid, config: &Config) -> Result { let (tx, rx): (Sender, Receiver) = mpsc::channel(); let (initialized_tx, initialized_rx): ( Sender>, Receiver>, ) = mpsc::channel(); let config = config.clone(); let sampling_thread = thread::spawn(move || { // We need to create this object inside the thread here since PythonSpy objects don't // have the Send trait implemented on linux let mut spy = match PythonSpy::retry_new(pid, &config, 20) { Ok(spy) => { if initialized_tx.send(Ok(spy.version.clone())).is_err() { return; } spy } Err(e) => { initialized_tx.send(Err(e)).unwrap(); return; } }; for sleep in Timer::new(spy.config.sampling_rate as f64) { let mut sampling_errors = None; let traces = match spy.get_stack_traces() { Ok(traces) => traces, Err(e) => { if spy.process.exe().is_err() { info!( "stopped sampling pid {} because the process exited", spy.pid ); break; } sampling_errors = Some(vec![(spy.pid, e)]); Vec::new() } }; let late = sleep.err(); if tx .send(Sample { traces, sampling_errors, late, }) .is_err() { break; } } }); let version = initialized_rx.recv()??; Ok(Sampler { rx: Some(rx), version: Some(version), sampling_thread: Some(sampling_thread), }) } /// Creates a new sampler object that samples any python process in the /// process or child processes fn new_subprocess_sampler(pid: Pid, config: &Config) -> Result { let process = remoteprocess::Process::new(pid)?; // Initialize a PythonSpy object per child, and build up the process tree let mut spies = HashMap::new(); let mut retries = 10; spies.insert(pid, PythonSpyThread::new(pid, None, config)?); loop { for (childpid, parentpid) in process.child_processes()? { // If we can't create the child process, don't worry about it // can happen with zombie child processes etc match PythonSpyThread::new(childpid, Some(parentpid), config) { Ok(spy) => { spies.insert(childpid, spy); } Err(e) => { warn!("Failed to open process {}: {}", childpid, e); } } } // wait for all the various python spy objects to initialize, and break out of here // if we have one of them started. if spies.values_mut().any(|spy| spy.wait_initialized()) { break; } // Otherwise sleep for a short time and retry retries -= 1; if retries == 0 { return Err(format_err!( "No python processes found in process {} or any of its subprocesses", pid )); } std::thread::sleep(std::time::Duration::from_millis(100)); } // Create a new thread to periodically monitor for new child processes, and update // the procesess map let spies = Arc::new(Mutex::new(spies)); let monitor_spies = spies.clone(); let monitor_config = config.clone(); std::thread::spawn(move || { while process.exe().is_ok() { match monitor_spies.lock() { Ok(mut spies) => { for (childpid, parentpid) in process .child_processes() .expect("failed to get subprocesses") { if spies.contains_key(&childpid) { continue; } match PythonSpyThread::new(childpid, Some(parentpid), &monitor_config) { Ok(spy) => { spies.insert(childpid, spy); } Err(e) => { warn!("Failed to create spy for {}: {}", childpid, e); } } } } Err(e) => { error!("Failed to acquire lock: {}", e); } } std::thread::sleep(Duration::from_millis(100)); } }); let mut process_info = HashMap::new(); // Create a new thread to generate samples let config = config.clone(); let (tx, rx): (Sender, Receiver) = mpsc::channel(); let sampling_thread = std::thread::spawn(move || { for sleep in Timer::new(config.sampling_rate as f64) { let mut traces = Vec::new(); let mut sampling_errors = None; let mut spies = match spies.lock() { Ok(current) => current, Err(e) => { error!("Failed to get process tree: {}", e); continue; } }; // Notify all the initialized spies to generate a trace for spy in spies.values_mut() { if spy.initialized() { spy.notify(); } } // collect the traces from each python spy if possible for spy in spies.values_mut() { match spy.collect() { Some(Ok(mut t)) => traces.append(&mut t), Some(Err(e)) => { let errors = sampling_errors.get_or_insert_with(Vec::new); errors.push((spy.process.pid, e)); } None => {} } } // Annotate each trace with the process info for trace in traces.iter_mut() { let pid = trace.pid; // Annotate each trace with the process info for the current let process = process_info .entry(pid) .or_insert_with(|| get_process_info(pid, &spies).map(|p| Arc::new(*p))); trace.process_info = process.clone(); } // Send the collected info back let late = sleep.err(); if tx .send(Sample { traces, sampling_errors, late, }) .is_err() { break; } // If all of our spies have stopped, we're done if spies.is_empty() || spies.values().all(|x| !x.running) { break; } } }); Ok(Sampler { rx: Some(rx), version: None, sampling_thread: Some(sampling_thread), }) } } impl Iterator for Sampler { type Item = Sample; fn next(&mut self) -> Option { self.rx.as_ref().unwrap().recv().ok() } } impl Drop for Sampler { fn drop(&mut self) { self.rx = None; if let Some(t) = self.sampling_thread.take() { t.join().unwrap(); } } } struct PythonSpyThread { initialized_rx: Receiver>, notify_tx: Sender<()>, sample_rx: Receiver, Error>>, initialized: Option>, pub running: bool, notified: bool, pub process: remoteprocess::Process, pub parent: Option, pub command_line: String, } impl PythonSpyThread { fn new(pid: Pid, parent: Option, config: &Config) -> Result { let (initialized_tx, initialized_rx): ( Sender>, Receiver>, ) = mpsc::channel(); let (notify_tx, notify_rx): (Sender<()>, Receiver<()>) = mpsc::channel(); let (sample_tx, sample_rx): ( Sender, Error>>, Receiver, Error>>, ) = mpsc::channel(); let config = config.clone(); let process = remoteprocess::Process::new(pid)?; let command_line = process .cmdline() .map(|x| x.join(" ")) .unwrap_or_else(|_| "".to_owned()); thread::spawn(move || { // We need to create this object inside the thread here since PythonSpy objects don't // have the Send trait implemented on linux let mut spy = match PythonSpy::retry_new(pid, &config, 5) { Ok(spy) => { if initialized_tx.send(Ok(spy.version.clone())).is_err() { return; } spy } Err(e) => { warn!("Failed to profile python from process {}: {}", pid, e); initialized_tx.send(Err(e)).unwrap(); return; } }; for _ in notify_rx.iter() { let result = spy.get_stack_traces(); if result.is_err() && spy.process.exe().is_err() { info!( "stopped sampling pid {} because the process exited", spy.pid ); break; } if sample_tx.send(result).is_err() { break; } } }); Ok(PythonSpyThread { initialized_rx, notify_tx, sample_rx, process, command_line, parent, initialized: None, running: false, notified: false, }) } fn wait_initialized(&mut self) -> bool { match self.initialized_rx.recv() { Ok(status) => { self.running = status.is_ok(); self.initialized = Some(status); self.running } Err(e) => { // shouldn't happen, but will be ok if it does warn!( "Failed to get initialization status from PythonSpyThread: {}", e ); false } } } fn initialized(&mut self) -> bool { if let Some(init) = self.initialized.as_ref() { return init.is_ok(); } match self.initialized_rx.try_recv() { Ok(status) => { self.running = status.is_ok(); self.initialized = Some(status); self.running } Err(std::sync::mpsc::TryRecvError::Empty) => false, Err(std::sync::mpsc::TryRecvError::Disconnected) => { // this *shouldn't* happen warn!("Failed to get initialization status from PythonSpyThread: disconnected"); false } } } fn notify(&mut self) { match self.notify_tx.send(()) { Ok(_) => { self.notified = true; } Err(_) => { self.running = false; } } } fn collect(&mut self) -> Option, Error>> { if !self.notified { return None; } self.notified = false; match self.sample_rx.recv() { Ok(sample) => Some(sample), Err(_) => { self.running = false; None } } } } fn get_process_info(pid: Pid, spies: &HashMap) -> Option> { spies.get(&pid).map(|spy| { let parent = spy .parent .and_then(|parentpid| get_process_info(parentpid, spies)); Box::new(ProcessInfo { pid, parent, command_line: spy.command_line.clone(), }) }) } ================================================ FILE: src/speedscope.rs ================================================ // This code is adapted from rbspy: // https://github.com/rbspy/rbspy/tree/master/src/ui/speedscope.rs // licensed under the MIT License: /* MIT License Copyright (c) 2016 Julia Evans, Kamal Marhubi Portions (continuous integration setup) Copyright (c) 2016 Jorge Aparicio Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ use std::collections::HashMap; use std::io; use std::io::Write; use crate::stack_trace; use remoteprocess::{Pid, Tid}; use anyhow::Error; use serde_derive::{Deserialize, Serialize}; use crate::config::Config; /* * This file contains code to export rbspy profiles for use in https://speedscope.app * * The TypeScript definitions that define this file format can be found here: * https://github.com/jlfwong/speedscope/blob/9d13d9/src/lib/file-format-spec.ts * * From the TypeScript definition, a JSON schema is generated. The latest * schema can be found here: https://speedscope.app/file-format-schema.json * * This JSON schema conveniently allows to generate type bindings for generating JSON. * You can use https://app.quicktype.io/ to generate serde_json Rust bindings for the * given JSON schema. * * There are multiple variants of the file format. The variant we're going to generate * is the "type: sampled" profile, since it most closely maps to rbspy's data recording * structure. */ #[derive(Debug, Deserialize, Serialize)] struct SpeedscopeFile { #[serde(rename = "$schema")] schema: String, profiles: Vec, shared: Shared, #[serde(rename = "activeProfileIndex")] active_profile_index: Option, exporter: Option, name: Option, } #[derive(Debug, Deserialize, Serialize)] struct Profile { #[serde(rename = "type")] profile_type: ProfileType, name: String, unit: ValueUnit, #[serde(rename = "startValue")] start_value: f64, #[serde(rename = "endValue")] end_value: f64, samples: Vec>, weights: Vec, } #[derive(Debug, Serialize, Deserialize)] struct Shared { frames: Vec, } #[derive(Debug, Clone, Serialize, Deserialize)] struct Frame { name: String, file: Option, line: Option, col: Option, } #[derive(Debug, Serialize, Deserialize)] enum ProfileType { #[serde(rename = "evented")] Evented, #[serde(rename = "sampled")] Sampled, } #[derive(Debug, Serialize, Deserialize, PartialEq, Eq)] enum ValueUnit { #[serde(rename = "bytes")] Bytes, #[serde(rename = "microseconds")] Microseconds, #[serde(rename = "milliseconds")] Milliseconds, #[serde(rename = "nanoseconds")] Nanoseconds, #[serde(rename = "none")] None, #[serde(rename = "seconds")] Seconds, } impl SpeedscopeFile { pub fn new( samples: &HashMap<(Pid, Tid), Vec>>, frames: &[Frame], thread_name_map: &HashMap<(Pid, Tid), String>, sample_rate: u64, ) -> SpeedscopeFile { let mut profiles: Vec = samples .iter() .map(|(thread_id, samples)| { let end_value = samples.len(); // we sample at 100 Hz, so scale the end value and weights to match the time unit let scaled_end_value = end_value as f64 / sample_rate as f64; let weights: Vec = samples .iter() .map(|_s| 1_f64 / sample_rate as f64) .collect(); Profile { profile_type: ProfileType::Sampled, name: thread_name_map .get(thread_id) .map_or_else(|| "py-spy".to_string(), |x| x.clone()), unit: ValueUnit::Seconds, start_value: 0.0, end_value: scaled_end_value, samples: samples.clone(), weights, } }) .collect(); profiles.sort_by(|a, b| a.name.cmp(&b.name)); SpeedscopeFile { // This is always the same schema: "https://www.speedscope.app/file-format-schema.json".to_string(), active_profile_index: None, name: Some("py-spy profile".to_string()), exporter: Some(format!("py-spy@{}", env!("CARGO_PKG_VERSION"))), profiles, shared: Shared { frames: frames.to_owned(), }, } } } impl Frame { pub fn new(stack_frame: &stack_trace::Frame, show_line_numbers: bool) -> Frame { Frame { name: stack_frame.name.clone(), // TODO: filename? file: Some(stack_frame.filename.clone()), line: if show_line_numbers { Some(stack_frame.line as u32) } else { None }, col: None, } } } pub struct Stats { samples: HashMap<(Pid, Tid), Vec>>, frames: Vec, frame_to_index: HashMap, thread_name_map: HashMap<(Pid, Tid), String>, config: Config, } impl Stats { pub fn new(config: &Config) -> Stats { Stats { samples: HashMap::new(), frames: vec![], frame_to_index: HashMap::new(), thread_name_map: HashMap::new(), config: config.clone(), } } pub fn record(&mut self, stack: &stack_trace::StackTrace) -> Result<(), io::Error> { let show_line_numbers = self.config.show_line_numbers; let mut frame_indices: Vec = stack .frames .iter() .map(|frame| { let frames = &mut self.frames; let mut key = frame.clone(); if !show_line_numbers { key.line = 0; } *self.frame_to_index.entry(key).or_insert_with(|| { let len = frames.len(); frames.push(Frame::new(frame, show_line_numbers)); len }) }) .collect(); frame_indices.reverse(); let key = (stack.pid as Pid, stack.thread_id as Tid); self.samples.entry(key).or_default().push(frame_indices); let subprocesses = self.config.subprocesses; self.thread_name_map.entry(key).or_insert_with(|| { let thread_name = stack .thread_name .as_ref() .map_or_else(|| "".to_string(), |x| x.clone()); if subprocesses { format!( "Process {} Thread {} \"{}\"", stack.pid, stack.format_threadid(), thread_name ) } else { format!("Thread {} \"{}\"", stack.format_threadid(), thread_name) } }); Ok(()) } pub fn write(&self, w: &mut dyn Write) -> Result<(), Error> { let json = serde_json::to_string(&SpeedscopeFile::new( &self.samples, &self.frames, &self.thread_name_map, self.config.sampling_rate, ))?; writeln!(w, "{json}")?; Ok(()) } } #[cfg(test)] mod tests { use super::*; use std::io::{Cursor, Read, Seek, SeekFrom}; #[test] fn test_speedscope_units() { let sample_rate = 100; let config = Config { show_line_numbers: true, sampling_rate: sample_rate, ..Default::default() }; let mut stats = Stats::new(&config); let mut cursor = Cursor::new(Vec::new()); let frame = stack_trace::Frame { name: String::from("test"), filename: String::from("test.py"), module: None, short_filename: None, line: 0, locals: None, is_entry: true, is_shim_entry: false, }; let trace = stack_trace::StackTrace { pid: 1, thread_id: 1, thread_name: None, os_thread_id: None, active: true, owns_gil: false, frames: vec![frame], process_info: None, }; stats.record(&trace).unwrap(); stats.write(&mut cursor).unwrap(); cursor.seek(SeekFrom::Start(0)).unwrap(); let mut s = String::new(); let read = cursor.read_to_string(&mut s).unwrap(); assert!(read > 0); let trace: SpeedscopeFile = serde_json::from_str(&s).unwrap(); assert_eq!(trace.profiles[0].unit, ValueUnit::Seconds); assert_eq!(trace.profiles[0].end_value, 1.0 / sample_rate as f64); } } ================================================ FILE: src/stack_trace.rs ================================================ use std::sync::Arc; use anyhow::{Context, Error, Result}; use remoteprocess::{Pid, ProcessMemory}; use serde_derive::Serialize; use crate::config::{Config, LineNo}; use crate::python_data_access::{copy_bytes, copy_string}; use crate::python_interpreters::{ CodeObject, FrameObject, InterpreterState, ThreadState, TupleObject, }; /// Call stack for a single python thread #[derive(Debug, Clone, Serialize)] pub struct StackTrace { /// The process id than generated this stack trace pub pid: Pid, /// The python thread id for this stack trace pub thread_id: u64, // The python thread name for this stack trace pub thread_name: Option, /// The OS thread id for this stack tracee pub os_thread_id: Option, /// Whether or not the thread was active pub active: bool, /// Whether or not the thread held the GIL pub owns_gil: bool, /// The frames pub frames: Vec, /// process commandline / parent process info pub process_info: Option>, } /// Information about a single function call in a stack trace #[derive(Debug, Hash, Eq, PartialEq, Ord, PartialOrd, Clone, Serialize)] pub struct Frame { /// The function name pub name: String, /// The full filename of the file pub filename: String, /// The module/shared library the pub module: Option, /// A short, more readable, representation of the filename pub short_filename: Option, /// The line number inside the file (or 0 for native frames without line information) pub line: i32, /// Local Variables associated with the frame pub locals: Option>, /// If this is an entry frame. Each entry frame corresponds to one native frame (Python 3.11) pub is_entry: bool, /// If the last frame was a shim. This is used in Python 3.12+ to detect entry frames. pub is_shim_entry: bool, } #[derive(Debug, Hash, Eq, PartialEq, Ord, PartialOrd, Clone, Serialize)] pub struct LocalVariable { pub name: String, pub addr: usize, pub arg: bool, pub repr: Option, } #[derive(Debug, Clone, Serialize)] pub struct ProcessInfo { pub pid: Pid, pub command_line: String, pub parent: Option>, } /// Given an InterpreterState, this function returns a vector of stack traces for each thread pub fn get_stack_traces( interpreter_address: usize, process: &P, threadstate_address: usize, config: Option<&Config>, ) -> Result, Error> where I: InterpreterState, P: ProcessMemory, { let gil_thread_id = get_gil_threadid::(threadstate_address, process)?; let threadstate_ptr_ptr = I::threadstate_ptr_ptr(interpreter_address); let mut threads: *const I::ThreadState = process .copy_struct(threadstate_ptr_ptr as usize) .context("Failed to copy PyThreadState head pointer")?; let mut ret = Vec::new(); let lineno = config.map(|c| c.lineno).unwrap_or(LineNo::NoLine); let dump_locals = config.map(|c| c.dump_locals).unwrap_or(0); while !threads.is_null() { let thread = process .copy_pointer(threads) .context("Failed to copy PyThreadState")?; let mut trace = get_stack_trace(&thread, process, dump_locals > 0, lineno)?; trace.owns_gil = trace.thread_id == gil_thread_id; ret.push(trace); // This seems to happen occasionally when scanning BSS addresses for valid interpreters if ret.len() > 4096 { return Err(format_err!("Max thread recursion depth reached")); } threads = thread.next(); } Ok(ret) } /// Gets a stack trace for an individual thread pub fn get_stack_trace( thread: &T, process: &P, copy_locals: bool, lineno: LineNo, ) -> Result where T: ThreadState, P: ProcessMemory, { // TODO: just return frames here? everything else probably should be returned out of scope let mut frames = Vec::new(); // python 3.11+ has an extra level of indirection to get the Frame from the threadstate let mut frame_address = thread.frame_address(); if let Some(addr) = frame_address { frame_address = Some(process.copy_struct(addr)?); } let mut frame_ptr = thread.frame(frame_address); // We are iterating in reverse, i.e. from last call to first call. // Since Python 3.12, there are shim frames inserted before a block // of Python frames. When we encounter one, update the last frame. let set_last_frame_as_shim_entry = &mut |frames: &mut Vec| { if let Some(frame) = frames.last_mut() { frame.is_shim_entry = true; } }; while !frame_ptr.is_null() { let frame = process .copy_pointer(frame_ptr) .context("Failed to copy PyFrameObject")?; let code = process .copy_pointer(frame.code()) .context("Failed to copy PyCodeObject")?; let filename = copy_string(code.filename(), process).context("Failed to copy filename"); let name = copy_string(code.name(), process).context("Failed to copy function name"); // just skip processing the current frame if we can't load the filename or function name. // this can happen in python 3.13+ since the f_executable isn't guaranteed to be // a PyCodeObject. We could check the type (and mimic the logic of PyCode_Check here) // but that would require extra overhead of reading the ob_type per frame - and we // would also have to figure out what the address of PyCode_Type is (which will be // easier if something like https://github.com/python/cpython/issues/100987#issuecomment-1487227139 // is merged ) if filename.is_err() || name.is_err() { frame_ptr = frame.back(); set_last_frame_as_shim_entry(&mut frames); continue; } let filename = filename?; let name = name?; // skip entries in python 3.12+ // Unset file/function name in py3.13 means this is a shim. if filename.is_empty() || filename == "" { frame_ptr = frame.back(); set_last_frame_as_shim_entry(&mut frames); continue; } let line = match lineno { LineNo::NoLine => 0, LineNo::First => code.first_lineno(), LineNo::LastInstruction => match get_line_number(&code, frame.lasti(), process) { Ok(line) => line, Err(e) => { // Failling to get the line number really shouldn't be fatal here, but // can happen in extreme cases (https://github.com/benfred/py-spy/issues/164) // Rather than fail set the linenumber to 0. This is used by the native extensions // to indicate that we can't load a line number and it should be handled gracefully warn!( "Failed to get line number from {}.{}: {}", filename, name, e ); 0 } }, }; let locals = if copy_locals { Some(get_locals(&code, frame_ptr, &frame, process)?) } else { None }; let is_entry = frame.is_entry(); frames.push(Frame { name, filename, line, short_filename: None, module: None, locals, is_entry, is_shim_entry: false, }); if frames.len() > 4096 { return Err(format_err!("Max frame recursion depth reached")); } frame_ptr = frame.back(); } // First frame is always a shim set_last_frame_as_shim_entry(&mut frames); Ok(StackTrace { pid: 0, frames, thread_id: thread.thread_id(), thread_name: None, owns_gil: false, active: true, os_thread_id: thread.native_thread_id(), process_info: None, }) } impl StackTrace { pub fn status_str(&self) -> &str { match (self.owns_gil, self.active) { (_, false) => "idle", (true, true) => "active+gil", (false, true) => "active", } } pub fn format_threadid(&self) -> String { // native threadids in osx are kinda useless, use the pthread id instead #[cfg(target_os = "macos")] return format!("{:#X}", self.thread_id); // otherwise use the native threadid if given #[cfg(not(target_os = "macos"))] match self.os_thread_id { Some(tid) => format!("{}", tid), None => format!("{:#X}", self.thread_id), } } } /// Returns the line number from a PyCodeObject (given the lasti index from a PyFrameObject) fn get_line_number( code: &C, lasti: i32, process: &P, ) -> Result { let table = copy_bytes(code.line_table(), process).context("Failed to copy line number table")?; Ok(code.get_line_number(lasti, &table)) } fn get_locals( code: &C, frameptr: *const F, frame: &F, process: &P, ) -> Result, Error> { let local_count = code.nlocals() as usize; let argcount = code.argcount() as usize; let varnames = process.copy_pointer(code.varnames())?; let ptr_size = std::mem::size_of::<*const i32>(); let locals_addr = frameptr as usize + std::mem::size_of_val(frame) - ptr_size; let mut ret = Vec::new(); for i in 0..local_count { let nameptr: *const C::StringObject = process.copy_struct(varnames.address(code.varnames() as usize, i))?; let name = copy_string(nameptr, process)?; let addr: usize = process.copy_struct(locals_addr + i * ptr_size)?; if addr == 0 { continue; } ret.push(LocalVariable { name, addr, arg: i < argcount, repr: None, }); } Ok(ret) } pub fn get_gil_threadid( threadstate_address: usize, process: &P, ) -> Result { // happens during initialization when checking to see if we have a valid interpreter (before we've figured out the threadstate_address) if threadstate_address == 0 { return Ok(0); } let addr = if I::HAS_GIL_RUNTIME_STATE { // get the gilruntimestate - note that this struct is identical between 3.12/3.13 let gil_state: crate::python_bindings::v3_13_0::_gil_runtime_state = process.copy_struct(threadstate_address)?; // check to see if the GIL is locked already if gil_state.locked != 0 { gil_state.last_holder as usize } else { 0 } } else { process.copy_struct::(threadstate_address)? }; // if the addr is 0, no thread is currently holding the GIL let threadid = if addr != 0 { let threadstate: I::ThreadState = process.copy_struct(addr)?; threadstate.thread_id() } else { 0 }; Ok(threadid) } impl ProcessInfo { pub fn to_frame(&self) -> Frame { Frame { name: format!("process {}:\"{}\"", self.pid, self.command_line), filename: String::from(""), module: None, short_filename: None, line: 0, locals: None, is_entry: true, is_shim_entry: true, } } } #[cfg(test)] mod tests { use super::*; use crate::python_bindings::v3_7_0::PyCodeObject; use crate::python_data_access::tests::to_byteobject; use remoteprocess::LocalProcess; #[test] fn test_get_line_number() { let mut lnotab = to_byteobject(&[0u8, 1, 10, 1, 8, 1, 4, 1]); let code = PyCodeObject { co_firstlineno: 3, co_lnotab: &mut lnotab.base.ob_base.ob_base, ..Default::default() }; let lineno = get_line_number(&code, 30, &LocalProcess).unwrap(); assert_eq!(lineno, 7); } } ================================================ FILE: src/timer.rs ================================================ use std::time::{Duration, Instant}; #[cfg(windows)] use winapi::um::timeapi; use rand_distr::{Distribution, Exp}; /// Timer is an iterator that sleeps an appropriate amount of time between iterations /// so that we can sample the process a certain number of times a second. /// We're using an irregular sampling strategy to avoid aliasing effects that can happen /// if the target process runs code at a similar schedule as the profiler: /// https://github.com/benfred/py-spy/issues/94 pub struct Timer { start: Instant, desired: Duration, exp: Exp, } impl Timer { pub fn new(rate: f64) -> Timer { // This changes a system-wide setting on Windows so that the OS wakes up every 1ms // instead of the default 15.6ms. This is required to have a sleep call // take less than 15ms, which we need since we usually profile at more than 64hz. // The downside is that this will increase power usage: good discussions are: // https://randomascii.wordpress.com/2013/07/08/windows-timer-resolution-megawatts-wasted/ // and http://www.belshe.com/2010/06/04/chrome-cranking-up-the-clock/ #[cfg(windows)] unsafe { timeapi::timeBeginPeriod(1); } let start = Instant::now(); Timer { start, desired: Duration::from_secs(0), exp: Exp::new(rate).unwrap(), } } } impl Iterator for Timer { type Item = Result; fn next(&mut self) -> Option { let elapsed = self.start.elapsed(); // figure out how many nanoseconds should come between the previous and // the next sample using an exponential distribution to avoid aliasing let nanos = 1_000_000_000.0 * self.exp.sample(&mut rand::thread_rng()); // since we want to account for the amount of time the sampling takes // we keep track of when we should sleep to (rather than just sleeping // the amount of time from the previous line). self.desired += Duration::from_nanos(nanos as u64); // sleep if appropriate, or warn if we are behind in sampling if self.desired > elapsed { std::thread::sleep(self.desired - elapsed); Some(Ok(self.desired - elapsed)) } else { Some(Err(elapsed - self.desired)) } } } impl Drop for Timer { fn drop(&mut self) { #[cfg(windows)] unsafe { timeapi::timeEndPeriod(1); } } } ================================================ FILE: src/utils.rs ================================================ use num_traits::{CheckedAdd, Zero}; use std::ops::Add; #[cfg(feature = "unwind")] pub fn resolve_filename(filename: &str, modulename: &str) -> Option { // check the filename first, if it exists use it use std::path::Path; let path = Path::new(filename); if path.exists() { return Some(filename.to_owned()); } // try resolving relative the shared library the file is in let module = Path::new(modulename); if let Some(parent) = module.parent() { if let Some(name) = path.file_name() { let temp = parent.join(name); if temp.exists() { return Some(temp.to_string_lossy().to_string()); } } } None } pub fn is_subrange( start: T, size: T, sub_start: T, sub_size: T, ) -> bool { !size.is_zero() && !sub_size.is_zero() && start.checked_add(&size).is_some() && sub_start.checked_add(&sub_size).is_some() && sub_start >= start && sub_start + sub_size <= start + size } pub fn offset_of(object: *const T, member: *const M) -> usize { member as usize - object as usize } #[cfg(test)] mod tests { use super::*; #[test] fn test_is_subrange() { assert!(is_subrange( 0u64, 0xffff_ffff_ffff_ffff, 0, 0xffff_ffff_ffff_ffff )); assert!(is_subrange(0, 1, 0, 1)); assert!(is_subrange(0, 100, 0, 10)); assert!(is_subrange(0, 100, 90, 10)); assert!(!is_subrange(0, 0, 0, 0)); assert!(!is_subrange(1, 0, 0, 0)); assert!(!is_subrange(1, 0, 1, 0)); assert!(!is_subrange(0, 0, 0, 1)); assert!(!is_subrange(0, 0, 1, 0)); assert!(!is_subrange( 1u64, 0xffff_ffff_ffff_ffff, 0, 0xffff_ffff_ffff_ffff )); assert!(!is_subrange( 0u64, 0xffff_ffff_ffff_ffff, 1, 0xffff_ffff_ffff_ffff )); assert!(!is_subrange(0, 10, 0, 11)); assert!(!is_subrange(0, 10, 1, 10)); assert!(!is_subrange(0, 10, 9, 2)); } } ================================================ FILE: src/version.rs ================================================ use lazy_static::lazy_static; use regex::bytes::Regex; use anyhow::Error; #[derive(Debug, PartialEq, Eq, Clone)] pub struct Version { pub major: u64, pub minor: u64, pub patch: u64, pub release_flags: String, pub build_metadata: Option, } impl Version { pub fn scan_bytes(data: &[u8]) -> Result { lazy_static! { static ref RE: Regex = Regex::new( r"((2|3)\.(3|4|5|6|7|8|9|10|11|12|13)\.(\d{1,2}))((a|b|c|rc)\d{1,2})?(\+(?:[0-9a-z-]+(?:[.][0-9a-z-]+)*)?)? (.{1,64})" ) .unwrap(); } if let Some(cap) = RE.captures_iter(data).next() { let release = match cap.get(5) { Some(x) => std::str::from_utf8(x.as_bytes())?, None => "", }; let major = std::str::from_utf8(&cap[2])?.parse::()?; let minor = std::str::from_utf8(&cap[3])?.parse::()?; let patch = std::str::from_utf8(&cap[4])?.parse::()?; let build_metadata = if let Some(s) = cap.get(7) { Some(std::str::from_utf8(&s.as_bytes()[1..])?.to_owned()) } else { None }; let version = std::str::from_utf8(&cap[0])?; info!("Found matching version string '{}'", version); #[cfg(windows)] { if version.contains("32 bit") { error!("32-bit python is not yet supported on windows! See https://github.com/benfred/py-spy/issues/31 for updates"); // we're panic'ing rather than returning an error, since we can't recover from this // and returning an error would just get the calling code to fall back to other // methods of trying to find the version panic!("32-bit python is unsupported on windows"); } } return Ok(Version { major, minor, patch, release_flags: release.to_owned(), build_metadata, }); } Err(format_err!("failed to find version string")) } } impl std::fmt::Display for Version { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { write!( f, "{}.{}.{}{}", self.major, self.minor, self.patch, self.release_flags )?; if let Some(build_metadata) = &self.build_metadata { write!(f, "+{build_metadata}",)? } Ok(()) } } #[cfg(test)] mod tests { use super::*; #[test] fn test_find_version() { let version = Version::scan_bytes(b"2.7.10 (default, Oct 6 2017, 22:29:07)").unwrap(); assert_eq!( version, Version { major: 2, minor: 7, patch: 10, release_flags: "".to_owned(), build_metadata: None, } ); let version = Version::scan_bytes( b"3.6.3 |Anaconda custom (64-bit)| (default, Oct 6 2017, 12:04:38)", ) .unwrap(); assert_eq!( version, Version { major: 3, minor: 6, patch: 3, release_flags: "".to_owned(), build_metadata: None, } ); let version = Version::scan_bytes(b"Python 3.7.0rc1 (v3.7.0rc1:dfad352267, Jul 20 2018, 13:27:54)") .unwrap(); assert_eq!( version, Version { major: 3, minor: 7, patch: 0, release_flags: "rc1".to_owned(), build_metadata: None, } ); let version = Version::scan_bytes(b"Python 3.10.0rc1 (tags/v3.10.0rc1, Aug 28 2021, 18:25:40)") .unwrap(); assert_eq!( version, Version { major: 3, minor: 10, patch: 0, release_flags: "rc1".to_owned(), build_metadata: None, } ); let version = Version::scan_bytes(b"1.7.0rc1 (v1.7.0rc1:dfad352267, Jul 20 2018, 13:27:54)"); assert!(version.is_err(), "don't match unsupported "); let version = Version::scan_bytes(b"3.7 10 "); assert!(version.is_err(), "needs dotted version"); let version = Version::scan_bytes(b"3.7.10fooboo "); assert!(version.is_err(), "limit suffixes"); // v2.7.15+ is a valid version string apparently: https://github.com/benfred/py-spy/issues/81 let version = Version::scan_bytes(b"2.7.15+ (default, Oct 2 2018, 22:12:08)").unwrap(); assert_eq!( version, Version { major: 2, minor: 7, patch: 15, release_flags: "".to_owned(), build_metadata: Some("".to_owned()), } ); let version = Version::scan_bytes(b"2.7.10+dcba (default)").unwrap(); assert_eq!( version, Version { major: 2, minor: 7, patch: 10, release_flags: "".to_owned(), build_metadata: Some("dcba".to_owned()), } ); let version = Version::scan_bytes(b"2.7.10+5-4.abcd (default)").unwrap(); assert_eq!( version, Version { major: 2, minor: 7, patch: 10, release_flags: "".to_owned(), build_metadata: Some("5-4.abcd".to_owned()), } ); let version = Version::scan_bytes(b"2.8.5+cinder (default)").unwrap(); assert_eq!( version, Version { major: 2, minor: 8, patch: 5, release_flags: "".to_owned(), build_metadata: Some("cinder".to_owned()), } ); } } ================================================ FILE: tests/integration_test.py ================================================ from __future__ import print_function import json import os import subprocess import sys import re import tempfile import unittest from collections import defaultdict, namedtuple from shutil import which Frame = namedtuple("Frame", ["file", "name", "line", "col"]) GIL = ["--gil"] PYSPY = which("py-spy") class TestPyspy(unittest.TestCase): """Basic tests of using py-spy as a commandline application""" def _sample_process(self, script_name, options=None, include_profile_name=False): if not PYSPY: raise ValueError("Failed to find py-spy on the path") # for permissions reasons, we really want to run the sampled python process as a # subprocess of the py-spy (works best on linux etc). So we're running the # record option, and setting different flags. To get the profile output # we're using the speedscope format (since we can read that in as json) with tempfile.NamedTemporaryFile() as profile_file: filename = profile_file.name if sys.platform.startswith("win"): filename = "profile.json" cmdline = [ PYSPY, "record", "-o", filename, "--format", "speedscope", "-d", "2", ] cmdline.extend(options or []) cmdline.extend(["--", sys.executable, script_name]) env = dict(os.environ, RUST_LOG="info") subprocess.check_output(cmdline, env=env) with open(filename) as f: profiles = json.load(f) frames = profiles["shared"]["frames"] samples = defaultdict(int) for p in profiles["profiles"]: for sample in p["samples"]: if include_profile_name: samples[ tuple( [p["name"]] + [Frame(**frames[frame]) for frame in sample] ) ] += 1 else: samples[tuple(Frame(**frames[frame]) for frame in sample)] += 1 return samples def test_longsleep(self): # running with the gil flag should have ~ no samples returned if GIL: profile = self._sample_process(_get_script("longsleep.py"), GIL) print(profile) assert sum(profile.values()) <= 10 # running with the idle flag should have > 95% of samples in the sleep call profile = self._sample_process(_get_script("longsleep.py"), ["--idle"]) sample, count = _most_frequent_sample(profile) assert count >= 95 assert len(sample) == 2 assert sample[0].name == "" assert sample[0].line == 9 assert sample[1].name == "longsleep" assert sample[1].line == 5 def test_busyloop(self): # can't be sure what line we're on, but we should have ~ all samples holding the gil profile = self._sample_process(_get_script("busyloop.py"), GIL) assert sum(profile.values()) >= 95 def test_thread_names(self): # we don't support getting thread names on python < 3.6 v = sys.version_info if v.major < 3 or v.minor < 6: return for _ in range(3): profile = self._sample_process( _get_script("thread_names.py"), ["--threads", "--idle"], include_profile_name=True, ) expected_thread_names = set("CustomThreadName-" + str(i) for i in range(10)) expected_thread_names.add("MainThread") name_re = re.compile(r"\"(.*)\"") actual_thread_names = {name_re.search(p[0]).groups()[0] for p in profile} if expected_thread_names == actual_thread_names: break if expected_thread_names != actual_thread_names: print( "failed to get thread names", expected_thread_names, actual_thread_names, ) assert expected_thread_names == actual_thread_names def test_shell_completions(self): cmdline = [PYSPY, "completions", "bash"] subprocess.check_output(cmdline) def _get_script(name): base_dir = os.path.dirname(__file__) return os.path.join(base_dir, "scripts", name) def _most_frequent_sample(samples): frames, count = max(samples.items(), key=lambda x: x[1]) # lets normalize as a percentage here, rather than raw number of samples return frames, int(100 * count / sum(samples.values())) if __name__ == "__main__": print("Testing py-spy @", PYSPY) unittest.main() ================================================ FILE: tests/integration_test.rs ================================================ extern crate py_spy; use py_spy::{Config, Pid, PythonSpy}; use std::collections::HashSet; struct ScriptRunner { #[allow(dead_code)] child: std::process::Child, } impl ScriptRunner { fn new(process_name: &str, filename: &str) -> ScriptRunner { let child = std::process::Command::new(process_name) .arg(filename) .spawn() .unwrap(); ScriptRunner { child } } fn id(&self) -> Pid { self.child.id() as _ } } impl Drop for ScriptRunner { fn drop(&mut self) { if let Err(err) = self.child.kill() { eprintln!("Failed to kill child process {}", err); } } } struct TestRunner { #[allow(dead_code)] child: ScriptRunner, spy: PythonSpy, } impl TestRunner { fn new(config: Config, filename: &str) -> TestRunner { let child = ScriptRunner::new("python", filename); std::thread::sleep(std::time::Duration::from_millis(400)); let spy = PythonSpy::retry_new(child.id(), &config, 20).unwrap(); TestRunner { child, spy } } } #[test] fn test_busy_loop() { #[cfg(target_os = "macos")] { // We need root permissions here to run this on OSX if unsafe { libc::geteuid() } != 0 { return; } } let mut runner = TestRunner::new(Config::default(), "./tests/scripts/busyloop.py"); let traces = runner.spy.get_stack_traces().unwrap(); // we can't be guaranteed what line the script is processing, but // we should be able to say that the script is active and // catch issues like https://github.com/benfred/py-spy/issues/141 assert!(traces[0].active); } #[cfg(feature = "unwind")] #[test] fn test_thread_reuse() { // on linux we had an issue with the pthread -> native thread id caching // the problem was that the pthreadids were getting re-used, // and this caused errors on native unwind (since the native thread had // exited). Test that this works with a simple script that creates // a couple short lived threads, and then profiling with native enabled let config = Config { native: true, ..Default::default() }; let mut runner = TestRunner::new(config, "./tests/scripts/thread_reuse.py"); let mut errors = 0; for _ in 0..100 { // should be able to get traces here BUT we do sometimes get errors about // not being able to suspend process ("No such file or directory (os error 2)" // when threads exit. Allow a small number of errors here. if let Err(e) = runner.spy.get_stack_traces() { println!("Failed to get traces {}", e); errors += 1; } std::thread::sleep(std::time::Duration::from_millis(20)); } assert!(errors <= 3); } #[test] fn test_long_sleep() { #[cfg(target_os = "macos")] { // We need root permissions here to run this on OSX if unsafe { libc::geteuid() } != 0 { return; } } let mut runner = TestRunner::new(Config::default(), "./tests/scripts/longsleep.py"); let traces = runner.spy.get_stack_traces().unwrap(); assert_eq!(traces.len(), 1); let trace = &traces[0]; // Make sure the stack trace is what we expect assert_eq!(trace.frames[0].name, "longsleep"); assert_eq!( trace.frames[0].short_filename, Some("longsleep.py".to_owned()) ); assert_eq!(trace.frames[0].line, 5); assert_eq!(trace.frames[1].name, ""); assert_eq!(trace.frames[1].line, 9); assert_eq!( trace.frames[1].short_filename, Some("longsleep.py".to_owned()) ); assert!(!traces[0].owns_gil); // we should reliably be able to detect the thread is sleeping on osx/windows // linux+freebsd is trickier #[cfg(any(target_os = "macos", target_os = "windows"))] assert!(!traces[0].active); } #[test] fn test_thread_names() { #[cfg(target_os = "macos")] { // We need root permissions here to run this on OSX if unsafe { libc::geteuid() } != 0 { return; } } let config = Config { include_idle: true, ..Default::default() }; let mut runner = TestRunner::new(config, "./tests/scripts/thread_names.py"); let traces = runner.spy.get_stack_traces().unwrap(); assert_eq!(traces.len(), 11); // dictionary + thread name lookup is only supported with python 3.6+ if runner.spy.version.major == 3 && runner.spy.version.minor >= 6 { let mut expected_threads: HashSet = (0..10).map(|n| format!("CustomThreadName-{}", n)).collect(); expected_threads.insert("MainThread".to_string()); let detected_threads: HashSet = traces .iter() .map(|trace| trace.thread_name.as_ref().unwrap().clone()) .collect(); assert_eq!(expected_threads, detected_threads); } else { for trace in traces.iter() { assert!(trace.thread_name.is_none()); } } } #[test] fn test_recursive() { #[cfg(target_os = "macos")] { // We need root permissions here to run this on OSX if unsafe { libc::geteuid() } != 0 { return; } } // there used to be a problem where the top-level functions being returned // weren't actually entry points: https://github.com/benfred/py-spy/issues/56 // This was fixed by locking the process while we are profiling it. Test that // the fix works by generating some samples from a program that would exhibit // this behaviour let mut runner = TestRunner::new(Config::default(), "./tests/scripts/recursive.py"); for _ in 0..100 { let traces = runner.spy.get_stack_traces().unwrap(); assert_eq!(traces.len(), 1); let trace = &traces[0]; assert!(trace.frames.len() <= 22); let top_level_frame = &trace.frames[trace.frames.len() - 1]; assert_eq!(top_level_frame.name, ""); assert!((top_level_frame.line == 8) || (top_level_frame.line == 7)); std::thread::sleep(std::time::Duration::from_millis(5)); } } #[test] fn test_unicode() { #[cfg(target_os = "macos")] { if unsafe { libc::geteuid() } != 0 { return; } } let mut runner = TestRunner::new(Config::default(), "./tests/scripts/unicode💩.py"); let traces = runner.spy.get_stack_traces().unwrap(); assert_eq!(traces.len(), 1); let trace = &traces[0]; assert_eq!(trace.frames[0].name, "function1"); assert_eq!( trace.frames[0].short_filename, Some("unicode💩.py".to_owned()) ); assert_eq!(trace.frames[0].line, 6); assert_eq!(trace.frames[1].name, ""); assert_eq!(trace.frames[1].line, 9); assert_eq!( trace.frames[1].short_filename, Some("unicode💩.py".to_owned()) ); assert!(!traces[0].owns_gil); } #[test] fn test_cyrillic() { #[cfg(target_os = "macos")] { if unsafe { libc::geteuid() } != 0 { return; } } // Identifiers with characters outside the ASCII range are supported from Python 3 let runner = TestRunner::new(Config::default(), "./tests/scripts/longsleep.py"); if runner.spy.version.major == 2 { return; } let mut runner = TestRunner::new(Config::default(), "./tests/scripts/cyrillic.py"); let traces = runner.spy.get_stack_traces().unwrap(); assert_eq!(traces.len(), 1); let trace = &traces[0]; assert_eq!(trace.frames[0].name, "кириллица"); assert_eq!(trace.frames[0].line, 4); assert_eq!(trace.frames[1].name, ""); assert_eq!(trace.frames[1].line, 7); } #[test] fn test_local_vars() { #[cfg(target_os = "macos")] { // We need root permissions here to run this on OSX if unsafe { libc::geteuid() } != 0 { return; } } let config = Config { dump_locals: 1, ..Default::default() }; let mut runner = TestRunner::new(config, "./tests/scripts/local_vars.py"); let traces = runner.spy.get_stack_traces().unwrap(); assert_eq!(traces.len(), 1); let trace = &traces[0]; assert_eq!(trace.frames.len(), 2); let frame = &trace.frames[0]; let locals = frame.locals.as_ref().unwrap(); assert_eq!(locals.len(), 29); let arg1 = &locals[0]; assert_eq!(arg1.name, "arg1"); assert!(arg1.arg); assert_eq!(arg1.repr, Some("\"foo\"".to_owned())); let arg2 = &locals[1]; assert_eq!(arg2.name, "arg2"); assert!(arg2.arg); assert_eq!(arg2.repr, Some("None".to_owned())); let arg3 = &locals[2]; assert_eq!(arg3.name, "arg3"); assert!(arg3.arg); assert_eq!(arg3.repr, Some("True".to_owned())); let local1 = &locals[3]; assert_eq!(local1.name, "local1"); assert!(!local1.arg); assert_eq!(local1.repr, Some("[-1234, 5678]".to_owned())); let local2 = &locals[4]; assert_eq!(local2.name, "local2"); assert!(!local2.arg); assert_eq!(local2.repr, Some("(\"a\", \"b\", \"c\")".to_owned())); let local3 = &locals[5]; assert_eq!(local3.name, "local3"); assert!(!local3.arg); assert_eq!(local3.repr, Some("123456789123456789".to_owned())); let local4 = &locals[6]; assert_eq!(local4.name, "local4"); assert!(!local4.arg); assert_eq!(local4.repr, Some("3.1415".to_owned())); let local5 = &locals[7]; assert_eq!(local5.name, "local5"); assert!(!local5.arg); let local6 = &locals[8]; assert_eq!(local6.name, "local6"); assert!(!local6.arg); // Numpy scalars let local7 = &locals[9]; assert_eq!(local7.name, "local7"); assert_eq!(local7.repr, Some("true".to_string())); let local8 = &locals[10]; assert_eq!(local8.name, "local8"); assert_eq!(local8.repr, Some("2".to_string())); let local9 = &locals[11]; assert_eq!(local9.name, "local9"); assert_eq!(local9.repr, Some("3".to_string())); let local10 = &locals[12]; assert_eq!(local10.name, "local10"); assert_eq!(local10.repr, Some("42".to_string())); let local11 = &locals[13]; assert_eq!(local11.name, "local11"); assert_eq!(local11.repr, Some("43".to_string())); let local12 = &locals[14]; assert_eq!(local12.name, "local12"); assert_eq!(local12.repr, Some("44".to_string())); let local13 = &locals[15]; assert_eq!(local13.name, "local13"); assert_eq!(local13.repr, Some("45".to_string())); let local14 = &locals[16]; assert_eq!(local14.name, "local14"); assert_eq!(local14.repr, Some("46".to_string())); let local15 = &locals[17]; assert_eq!(local15.name, "local15"); assert_eq!(local15.repr, Some("7".to_string())); let local16 = &locals[18]; assert_eq!(local16.name, "local16"); assert_eq!(local16.repr, Some("8".to_string())); fn test_repr_prefix(local: &py_spy::stack_trace::LocalVariable, expected: &str) { assert!( local .repr .as_ref() .map(|result| result.starts_with(expected)) .unwrap_or(false), "local '{}' repr = '{:?}' doesn't start with '{}'", &local.name, &local.repr, expected ); } let local17 = &locals[19]; assert_eq!(local17.name, "local17"); #[cfg(not(windows))] test_repr_prefix(local17, "= 6 { assert_eq!( local5.repr, Some("{\"a\": False, \"b\": (1, 2, 3)}".to_owned()) ); } } #[cfg(not(target_os = "freebsd"))] #[test] fn test_subprocesses() { #[cfg(target_os = "macos")] { // We need root permissions here to run this on OSX if unsafe { libc::geteuid() } != 0 { return; } } // We used to not be able to create a sampler object if one of the child processes // was in a zombie state. Verify that this works now let process = ScriptRunner::new("python", "./tests/scripts/subprocesses.py"); std::thread::sleep(std::time::Duration::from_millis(1000)); let config = Config { subprocesses: true, ..Default::default() }; let sampler = py_spy::sampler::Sampler::new(process.id(), &config).unwrap(); std::thread::sleep(std::time::Duration::from_millis(1000)); // Get samples from all the subprocesses, verify that we got from all 3 processes let mut attempts = 0; for sample in sampler { // wait for other processes here if we don't have the expected number let traces = sample.traces; if traces.len() != 3 && attempts < 4 { attempts += 1; std::thread::sleep(std::time::Duration::from_millis(1000)); continue; } assert_eq!(traces.len(), 3); assert!(traces[0].pid != traces[1].pid); assert!(traces[1].pid != traces[2].pid); break; } } #[cfg(not(target_os = "freebsd"))] #[test] fn test_subprocesses_zombiechild() { #[cfg(target_os = "macos")] { // We need root permissions here to run this on OSX if unsafe { libc::geteuid() } != 0 { return; } } // We used to not be able to create a sampler object if one of the child processes // was in a zombie state. Verify that this works now let process = ScriptRunner::new("python", "./tests/scripts/subprocesses_zombie_child.py"); std::thread::sleep(std::time::Duration::from_millis(200)); let config = Config { subprocesses: true, ..Default::default() }; let _sampler = py_spy::sampler::Sampler::new(process.id(), &config).unwrap(); } #[test] fn test_negative_linenumber_increment() { #[cfg(target_os = "macos")] { // We need root permissions here to run this on OSX if unsafe { libc::geteuid() } != 0 { return; } } let mut runner = TestRunner::new( Config::default(), "./tests/scripts/negative_linenumber_offsets.py", ); let traces = runner.spy.get_stack_traces().unwrap(); assert_eq!(traces.len(), 1); let trace = &traces[0]; // Python 3.12 inlined comprehensions - see https://peps.python.org/pep-0709/ match (runner.spy.version.major, runner.spy.version.minor) { (3, 0..=11) => { assert_eq!(trace.frames[0].name, ""); assert!(trace.frames[0].line >= 5 && trace.frames[0].line <= 10); assert_eq!(trace.frames[1].name, "f"); assert!(trace.frames[1].line >= 5 && trace.frames[0].line <= 10); assert_eq!(trace.frames[2].name, ""); assert_eq!(trace.frames[2].line, 13) } (2, _) | (3, 12..) => { assert_eq!(trace.frames[0].name, "f"); assert!(trace.frames[0].line >= 5 && trace.frames[0].line <= 10); assert_eq!(trace.frames[1].name, ""); assert_eq!(trace.frames[1].line, 13); } _ => panic!("Unknown python major version"), } } #[cfg(target_os = "linux")] #[test] fn test_delayed_subprocess() { let process = ScriptRunner::new("bash", "./tests/scripts/delayed_launch.sh"); let config = Config { subprocesses: true, ..Default::default() }; let sampler = py_spy::sampler::Sampler::new(process.id(), &config).unwrap(); for sample in sampler { // should have one trace from the subprocess let traces = sample.traces; assert_eq!(traces.len(), 1); assert!(traces[0].pid != process.id()); break; } } ================================================ FILE: tests/scripts/busyloop.py ================================================ def busy_loop(): while True: pass if __name__ == "__main__": busy_loop() ================================================ FILE: tests/scripts/cyrillic.py ================================================ import time def кириллица(seconds): time.sleep(seconds) if __name__ == "__main__": кириллица(100) ================================================ FILE: tests/scripts/delayed_launch.sh ================================================ sleep 0.5 python -c "import time; time.sleep(1000)" ================================================ FILE: tests/scripts/local_vars.py ================================================ import time import numpy as np def local_variable_lookup(arg1="foo", arg2=None, arg3=True): local1 = [-1234, 5678] local2 = ("a", "b", "c") local3 = 123456789123456789 local4 = 3.1415 local5 = {"a": False, "b": (1, 2, 3)} # https://github.com/benfred/py-spy/issues/224 local6 = ("-" * 115, {"key": {"key": {"key": "value"}}}) # Numpy scalars # integers local7 = np.bool(True) local8 = np.byte(2) local9 = np.int8(3) local10 = np.int16(42) local11 = np.int32(43) local12 = np.int64(44) local13 = np.uint8(45) local14 = np.uint16(46) local15 = np.uint32(7) local16 = np.uint64(8) local17 = np.ulonglong(11) # Floats local18 = np.float16(0.3) local19 = np.float32(0.5) local20 = np.float64(0.7) local21 = np.longdouble(0.9) # Complex local22 = np.complex64(0.3+5j) local23 = np.complex128(0.3+5j) local24 = np.clongdouble(0.3+5j) # https://github.com/benfred/py-spy/issues/766 local25 = "测试1" * 500 # Empty strings should not be ignored local26 = "" time.sleep(100000) if __name__ == "__main__": local_variable_lookup() ================================================ FILE: tests/scripts/longsleep.py ================================================ import time def longsleep(): time.sleep(100000) if __name__ == "__main__": longsleep() ================================================ FILE: tests/scripts/negative_linenumber_offsets.py ================================================ import time def f(): [ # Must be split over multiple lines to see the error. # https://github.com/benfred/py-spy/pull/208 time.sleep(1) for _ in range(1000) ] f() ================================================ FILE: tests/scripts/recursive.py ================================================ def recurse(x): if x == 0: return recurse(x-1) while True: recurse(20) ================================================ FILE: tests/scripts/subprocesses.py ================================================ import time import multiprocessing def target(): multiprocessing.freeze_support() time.sleep(1000) def main(): child1 = multiprocessing.Process(target=target) child1.start() child2 = multiprocessing.Process(target=target) child2.start() time.sleep(10000) child1.join() child2.join() if __name__ == "__main__": multiprocessing.freeze_support() main() ================================================ FILE: tests/scripts/subprocesses_zombie_child.py ================================================ import time import multiprocessing def target(): pass if __name__ == "__main__": multiprocessing.freeze_support() child = multiprocessing.Process(target=target) child.start() time.sleep(10000) child.join() ================================================ FILE: tests/scripts/thread_names.py ================================================ import time import threading def main(): for i in range(10): th = threading.Thread(target = lambda: time.sleep(10000)) th.name = "CustomThreadName-%s" % i th.start() time.sleep(10000) if __name__ == "__main__": main() ================================================ FILE: tests/scripts/thread_reuse.py ================================================ import time import threading while True: th = threading.Thread(target = lambda: time.sleep(.5)) th.start() th.join() ================================================ FILE: tests/scripts/unicode💩.py ================================================ #!/env/bin/python # -*- coding: utf-8 -*- import time def function1(seconds): time.sleep(seconds) if __name__ == "__main__": function1(100)